diff --git kudu-handler/src/test/results/positive/kudu_complex_queries.q.out kudu-handler/src/test/results/positive/kudu_complex_queries.q.out index 1324b27f8e..73fc3e514f 100644 --- kudu-handler/src/test/results/positive/kudu_complex_queries.q.out +++ kudu-handler/src/test/results/positive/kudu_complex_queries.q.out @@ -130,16 +130,22 @@ STAGE PLANS: 1 UDFToDouble(_col0) (type: double) outputColumnNames: _col1, _col2 Statistics: Num rows: 488 Data size: 86864 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: string), _col2 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: _col1 (type: string), _col2 (type: string) + null sort order: zz Statistics: Num rows: 488 Data size: 86864 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: ++ + top n: 10 + Select Operator + expressions: _col1 (type: string), _col2 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 488 Data size: 86864 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 488 Data size: 86864 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: vectorized Reduce Operator Tree: @@ -306,17 +312,23 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 121 Data size: 23232 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: int), _col2 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 121 Data size: 22748 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: string) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: _col2 (type: string) + null sort order: z + Statistics: Num rows: 121 Data size: 23232 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Select Operator + expressions: _col1 (type: int), _col2 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 121 Data size: 22748 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: int) + Reduce Output Operator + key expressions: _col1 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 121 Data size: 22748 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: int) Reducer 4 Execution mode: vectorized Reduce Operator Tree: diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/TopNKeyOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/TopNKeyOperator.java index bbbde7978b..b7c1250220 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/TopNKeyOperator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/TopNKeyOperator.java @@ -59,29 +59,27 @@ protected void initializeOp(Configuration hconf) throws HiveException { String nullSortOrder = conf.getNullOrder(); ObjectInspector rowInspector = inputObjInspectors[0]; - ObjectInspector standardObjInspector = ObjectInspectorUtils.getStandardObjectInspector(rowInspector); outputObjInspector = rowInspector; // init keyFields int numKeys = conf.getKeyColumns().size(); ExprNodeEvaluator[] keyFields = new ExprNodeEvaluator[numKeys]; ObjectInspector[] keyObjectInspectors = new ObjectInspector[numKeys]; - ExprNodeEvaluator[] standardKeyFields = new ExprNodeEvaluator[numKeys]; - ObjectInspector[] standardKeyObjectInspectors = new ObjectInspector[numKeys]; + ObjectInspector[] currentKeyObjectInspectors = new ObjectInspector[numKeys]; for (int i = 0; i < numKeys; i++) { ExprNodeDesc key = conf.getKeyColumns().get(i); keyFields[i] = ExprNodeEvaluatorFactory.get(key, hconf); keyObjectInspectors[i] = keyFields[i].initialize(rowInspector); - standardKeyFields[i] = ExprNodeEvaluatorFactory.get(key, hconf); - standardKeyObjectInspectors[i] = standardKeyFields[i].initialize(standardObjInspector); + currentKeyObjectInspectors[i] = ObjectInspectorUtils.getStandardObjectInspector(keyObjectInspectors[i], + ObjectInspectorUtils.ObjectInspectorCopyOption.WRITABLE); } this.topNKeyFilter = new TopNKeyFilter<>(conf.getTopN(), new KeyWrapperComparator( - keyObjectInspectors, standardKeyObjectInspectors, columnSortOrder, nullSortOrder)); + keyObjectInspectors, currentKeyObjectInspectors, columnSortOrder, nullSortOrder)); KeyWrapperFactory keyWrapperFactory = new KeyWrapperFactory(keyFields, keyObjectInspectors, - standardKeyObjectInspectors); + currentKeyObjectInspectors); keyWrapper = keyWrapperFactory.getKeyWrapper(); } diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java index 6876787e11..6aaf8da33e 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/physical/Vectorizer.java @@ -4332,9 +4332,17 @@ private boolean usesVectorUDFAdaptor(VectorExpression[] vecExprs) { VectorTopNKeyDesc vectorTopNKeyDesc) throws HiveException { TopNKeyDesc topNKeyDesc = (TopNKeyDesc) topNKeyOperator.getConf(); + VectorExpression[] keyExpressions; + // this will mark all actual computed columns + vContext.markActualScratchColumns(); + try { + List keyColumns = topNKeyDesc.getKeyColumns(); + keyExpressions = vContext.getVectorExpressionsUpConvertDecimal64(keyColumns); + fixDecimalDataTypePhysicalVariations(vContext, keyExpressions); + } finally { + vContext.freeMarkedScratchColumns(); + } - List keyColumns = topNKeyDesc.getKeyColumns(); - VectorExpression[] keyExpressions = vContext.getVectorExpressionsUpConvertDecimal64(keyColumns); vectorTopNKeyDesc.setKeyExpressions(keyExpressions); return OperatorFactory.getVectorOperator( topNKeyOperator.getCompilationOpContext(), topNKeyDesc, diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/CommonKeyPrefix.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/CommonKeyPrefix.java new file mode 100644 index 0000000000..049466050b --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/CommonKeyPrefix.java @@ -0,0 +1,189 @@ +/* + * 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.topnkey; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.stream.Stream; + +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.plan.GroupByDesc; +import org.apache.hadoop.hive.ql.plan.ReduceSinkDesc; +import org.apache.hadoop.hive.ql.plan.TopNKeyDesc; + +/** + * Holds result of a common key prefix of two operators. + * Provides factory methods for mapping TopNKey operator keys to GroupBy and ReduceSink operator keys. + */ +public final class CommonKeyPrefix { + + /** + * Factory method to map a {@link org.apache.hadoop.hive.ql.exec.TopNKeyOperator}'s and a + * {@link org.apache.hadoop.hive.ql.exec.GroupByOperator}'s keys. + * This method calls the {@link #map(List, String, String, List, Map, String, String)} method to do the mapping. + * Since the {@link GroupByDesc} does not contains any ordering information {@link TopNKeyDesc} ordering is passed + * for both operators. + * @param topNKeyDesc {@link TopNKeyDesc} contains {@link org.apache.hadoop.hive.ql.exec.TopNKeyOperator} keys. + * @param groupByDesc {@link GroupByDesc} contains {@link org.apache.hadoop.hive.ql.exec.GroupByOperator} keys. + * @return {@link CommonKeyPrefix} object containing common key prefix of the mapped operators. + */ + public static CommonKeyPrefix map(TopNKeyDesc topNKeyDesc, GroupByDesc groupByDesc) { + return map(topNKeyDesc.getKeyColumns(), topNKeyDesc.getColumnSortOrder(), topNKeyDesc.getNullOrder(), + groupByDesc.getKeys(), groupByDesc.getColumnExprMap(), + topNKeyDesc.getColumnSortOrder(), topNKeyDesc.getNullOrder()); + } + + /** + * Factory method to map a {@link org.apache.hadoop.hive.ql.exec.TopNKeyOperator}'s and + * a {@link org.apache.hadoop.hive.ql.exec.ReduceSinkOperator}'s keys. + * This method calls the {@link #map(List, String, String, List, Map, String, String)} method to do the mapping. + * @param topNKeyDesc {@link TopNKeyDesc} contains {@link org.apache.hadoop.hive.ql.exec.TopNKeyOperator} keys. + * @param reduceSinkDesc {@link ReduceSinkDesc} contains + * {@link org.apache.hadoop.hive.ql.exec.ReduceSinkOperator} keys. + * @return {@link CommonKeyPrefix} object containing common key prefix of the mapped operators. + */ + public static CommonKeyPrefix map(TopNKeyDesc topNKeyDesc, ReduceSinkDesc reduceSinkDesc) { + return map(topNKeyDesc.getKeyColumns(), topNKeyDesc.getColumnSortOrder(), topNKeyDesc.getNullOrder(), + reduceSinkDesc.getKeyCols(), reduceSinkDesc.getColumnExprMap(), + reduceSinkDesc.getOrder(), reduceSinkDesc.getNullOrder()); + } + + /** + * General factory method to map two operator keys. + * Two keys are considered to be equal + * - if parent operator's parentColExprMap has an entry with the operator key column name + * - and that entry value has the same index as the operator key column index. + * - and both key columns has the same ordering + * - and both key columns has the same null ordering + * + * Ex.: op1: a, b, c, d + * op2: a, b, e + * result: a, b + * + * opKeys: Column[_col0], Column[_col1], Column[_col2], Column[_col3] + * parentKeys: Column[KEY._col0], Column[KEY._col1], Column[KEY._col4] + * parentColExprMap: {_col0 -> Column[KEY._col0]}, {_col1 -> Column[KEY._col1]}, {_col4 -> Column[KEY._col4]} + * + * Column ordering and null ordering is given by a string where each character represents a column order/null order. + * Ex.: a ASC NULLS FIRST, b DESC NULLS LAST, c ASC NULLS LAST -> order="+-+", null order="azz" + * + * When parentColExprMap is null this method falls back to + * {@link #map(List, String, String, List, String, String)}. + * + * @param opKeys {@link List} of {@link ExprNodeDesc}. contains the operator's key columns + * @param opOrder operator's key column ordering in {@link String} format + * @param opNullOrder operator's key column null ordering in {@link String} format + * @param parentKeys {@link List} of {@link ExprNodeDesc}. contains the parent operator's key columns + * @param parentColExprMap {@link Map} of {@link String} -> {@link ExprNodeDesc}. + * contains parent operator's key column name {@link ExprNodeDesc} mapping + * @param parentOrder parent operator's key column ordering in {@link String} format + * @param parentNullOrder parent operator's key column null ordering in {@link String} format + * @return {@link CommonKeyPrefix} object containing the common key prefix of the mapped operators. + */ + public static CommonKeyPrefix map( + List opKeys, String opOrder, String opNullOrder, + List parentKeys, Map parentColExprMap, + String parentOrder, String parentNullOrder) { + + if (parentColExprMap == null) { + return map(opKeys, opOrder, opNullOrder, parentKeys, parentOrder, parentNullOrder); + } + + CommonKeyPrefix commonPrefix = new CommonKeyPrefix(); + int size = Stream.of(opKeys.size(), opOrder.length(), opNullOrder.length(), + parentKeys.size(), parentColExprMap.size(), parentOrder.length(), parentNullOrder.length()) + .min(Integer::compareTo) + .orElse(0); + + for (int i = 0; i < size; ++i) { + ExprNodeDesc column = opKeys.get(i); + String columnName = column.getExprString(); + ExprNodeDesc parentKey = parentKeys.get(i); + if (parentKey != null && parentKey.isSame(parentColExprMap.get(columnName)) && + opOrder.charAt(i) == parentOrder.charAt(i) && + opNullOrder.charAt(i) == parentNullOrder.charAt(i)) { + commonPrefix.add(parentKey, opOrder.charAt(i), opNullOrder.charAt(i)); + } else { + return commonPrefix; + } + } + return commonPrefix; + } + + // General factory method to map two operator keys. Operator's and parent operator's {@link ExprNodeDesc}s are + // compared using the + // {@link ExprNodeDesc.isSame} method. + public static CommonKeyPrefix map( + List opKeys, String opOrder, String opNullOrder, + List parentKeys, + String parentOrder, String parentNullOrder) { + + CommonKeyPrefix commonPrefix = new CommonKeyPrefix(); + int size = Stream.of(opKeys.size(), opOrder.length(), opNullOrder.length(), + parentKeys.size(), parentOrder.length(), parentNullOrder.length()) + .min(Integer::compareTo) + .orElse(0); + + for (int i = 0; i < size; ++i) { + ExprNodeDesc opKey = opKeys.get(i); + ExprNodeDesc parentKey = parentKeys.get(i); + if (opKey != null && opKey.isSame(parentKey) && + opOrder.charAt(i) == parentOrder.charAt(i) && + opNullOrder.charAt(i) == parentNullOrder.charAt(i)) { + commonPrefix.add(parentKey, opOrder.charAt(i), opNullOrder.charAt(i)); + } else { + return commonPrefix; + } + } + return commonPrefix; + } + + private List mappedColumns = new ArrayList<>(); + private StringBuilder mappedOrder = new StringBuilder(); + private StringBuilder mappedNullOrder = new StringBuilder(); + + private CommonKeyPrefix() { + } + + public void add(ExprNodeDesc column, char order, char nullOrder) { + mappedColumns.add(column); + mappedOrder.append(order); + mappedNullOrder.append(nullOrder); + } + + public boolean isEmpty() { + return mappedColumns.isEmpty(); + } + + public List getMappedColumns() { + return mappedColumns; + } + + public String getMappedOrder() { + return mappedOrder.toString(); + } + + public String getMappedNullOrder() { + return mappedNullOrder.toString(); + } + + public int size() { + return mappedColumns.size(); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/TopNKeyProcessor.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/TopNKeyProcessor.java similarity index 52% rename from ql/src/java/org/apache/hadoop/hive/ql/optimizer/TopNKeyProcessor.java rename to ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/TopNKeyProcessor.java index 0d6cf3c755..ce6efa4919 100644 --- ql/src/java/org/apache/hadoop/hive/ql/optimizer/TopNKeyProcessor.java +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/TopNKeyProcessor.java @@ -1,4 +1,4 @@ -/** +/* * 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 @@ -15,9 +15,8 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.apache.hadoop.hive.ql.optimizer; +package org.apache.hadoop.hive.ql.optimizer.topnkey; -import org.apache.hadoop.hive.ql.exec.GroupByOperator; import org.apache.hadoop.hive.ql.exec.Operator; import org.apache.hadoop.hive.ql.exec.OperatorFactory; import org.apache.hadoop.hive.ql.exec.ReduceSinkOperator; @@ -27,23 +26,18 @@ import org.apache.hadoop.hive.ql.lib.NodeProcessor; import org.apache.hadoop.hive.ql.lib.NodeProcessorCtx; import org.apache.hadoop.hive.ql.parse.SemanticException; -import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; -import org.apache.hadoop.hive.ql.plan.ExprNodeDescUtils; -import org.apache.hadoop.hive.ql.plan.GroupByDesc; import org.apache.hadoop.hive.ql.plan.OperatorDesc; import org.apache.hadoop.hive.ql.plan.ReduceSinkDesc; import org.apache.hadoop.hive.ql.plan.TopNKeyDesc; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import java.util.ArrayList; import java.util.List; import java.util.Stack; /** - * TopNKeyProcessor is a processor for TopNKeyOperator. A TopNKeyOperator will be placed between - * a GroupByOperator and its following ReduceSinkOperator. If there already is a TopNKeyOperator, - * then it will be skipped. + * TopNKeyProcessor is a processor for TopNKeyOperator. + * A TopNKeyOperator will be placed before any ReduceSinkOperator which has a topN property >= 0. */ public class TopNKeyProcessor implements NodeProcessor { private static final Logger LOG = LoggerFactory.getLogger(TopNKeyProcessor.class); @@ -59,12 +53,8 @@ public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, ReduceSinkOperator reduceSinkOperator = (ReduceSinkOperator) nd; ReduceSinkDesc reduceSinkDesc = reduceSinkOperator.getConf(); - // Get GroupByOperator - GroupByOperator groupByOperator = (GroupByOperator) reduceSinkOperator.getParentOperators().get(0); - GroupByDesc groupByDesc = groupByOperator.getConf(); - // Check whether the reduce sink operator contains top n - if (!reduceSinkDesc.isOrdering() || reduceSinkDesc.getTopN() < 0) { + if (reduceSinkDesc.getTopN() < 0 || !reduceSinkDesc.isOrdering()) { return null; } @@ -74,42 +64,35 @@ public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, return null; } - // Check whether the group by operator is in hash mode - if (groupByDesc.getMode() != GroupByDesc.Mode.HASH) { - return null; - } - - // Check whether the group by operator has distinct aggregations - if (groupByDesc.isDistinct()) { - return null; - } - - // Check whether RS keys are same as GBY keys - List groupByKeyColumns = groupByDesc.getKeys(); - List mappedColumns = new ArrayList<>(); - for (ExprNodeDesc columns : reduceSinkDesc.getKeyCols()) { - mappedColumns.add(groupByDesc.getColumnExprMap().get(columns.getExprString())); - } - if (!ExprNodeDescUtils.isSame(mappedColumns, groupByKeyColumns)) { - return null; - } - // Check whether there already is a top n key operator - Operator parentOperator = groupByOperator.getParentOperators().get(0); + Operator parentOperator = reduceSinkOperator.getParentOperators().get(0); if (parentOperator instanceof TopNKeyOperator) { return null; } - // Insert a new top n key operator between the group by operator and its parent - TopNKeyDesc topNKeyDesc = new TopNKeyDesc( - reduceSinkDesc.getTopN(), reduceSinkDesc.getOrder(), reduceSinkDesc.getNullOrder(), groupByKeyColumns); - Operator newOperator = OperatorFactory.getAndMakeChild( - groupByOperator.getCompilationOpContext(), (OperatorDesc) topNKeyDesc, - new RowSchema(groupByOperator.getSchema()), groupByOperator.getParentOperators()); - newOperator.getChildOperators().add(groupByOperator); - groupByOperator.getParentOperators().add(newOperator); - parentOperator.removeChild(groupByOperator); + TopNKeyDesc topNKeyDesc = new TopNKeyDesc(reduceSinkDesc.getTopN(), reduceSinkDesc.getOrder(), + reduceSinkDesc.getNullOrder(), reduceSinkDesc.getKeyCols()); + copyDown(reduceSinkOperator, topNKeyDesc); return null; } + + static TopNKeyOperator copyDown(Operator child, OperatorDesc operatorDesc) { + final List> parents = child.getParentOperators(); + + final Operator newOperator = + OperatorFactory.getAndMakeChild( + child.getCompilationOpContext(), operatorDesc, + new RowSchema(parents.get(0).getSchema()), child.getParentOperators()); + + newOperator.getChildOperators().add(child); + + for (Operator parent : parents) { + parent.removeChild(child); + } + child.getParentOperators().clear(); + child.getParentOperators().add(newOperator); + + return (TopNKeyOperator) newOperator; + } } diff --git ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/TopNKeyPushdownProcessor.java ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/TopNKeyPushdownProcessor.java new file mode 100644 index 0000000000..c79c371a8b --- /dev/null +++ ql/src/java/org/apache/hadoop/hive/ql/optimizer/topnkey/TopNKeyPushdownProcessor.java @@ -0,0 +1,365 @@ +/* + * 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.topnkey; + +import org.apache.hadoop.hive.ql.exec.CommonJoinOperator; +import org.apache.hadoop.hive.ql.exec.GroupByOperator; +import org.apache.hadoop.hive.ql.exec.Operator; +import org.apache.hadoop.hive.ql.exec.ReduceSinkOperator; +import org.apache.hadoop.hive.ql.exec.SelectOperator; +import org.apache.hadoop.hive.ql.exec.TopNKeyOperator; +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.parse.SemanticException; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +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.OperatorDesc; +import org.apache.hadoop.hive.ql.plan.ReduceSinkDesc; +import org.apache.hadoop.hive.ql.plan.TopNKeyDesc; +import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Stack; + +import static org.apache.hadoop.hive.ql.optimizer.topnkey.TopNKeyProcessor.copyDown; + +/** + * Implementation of TopNKey operator pushdown. + */ +public class TopNKeyPushdownProcessor implements NodeProcessor { + private static final Logger LOG = LoggerFactory.getLogger(TopNKeyPushdownProcessor.class); + + @Override + public Object process(Node nd, Stack stack, NodeProcessorCtx procCtx, + Object... nodeOutputs) throws SemanticException { + pushdown((TopNKeyOperator) nd); + return null; + } + + private void pushdown(TopNKeyOperator topNKey) throws SemanticException { + + final Operator parent = + topNKey.getParentOperators().get(0); + + switch (parent.getType()) { + case SELECT: + pushdownThroughSelect(topNKey); + break; + + case FORWARD: + pushdownThroughParent(topNKey); + break; + + case GROUPBY: + pushdownThroughGroupBy(topNKey); + break; + + case REDUCESINK: + pushdownThroughReduceSink(topNKey); + break; + + case MERGEJOIN: + case JOIN: + pushDownThroughJoin(topNKey); + break; + + case TOPNKEY: + pushdownThroughTopNKey(topNKey); + break; + + default: + break; + } + } + + /** + * Push through Project if expression(s) in TopNKey can be mapped to expression(s) based on Project input. + * + * @param topNKey TopNKey operator to push + * @throws SemanticException when removeChildAndAdoptItsChildren was not successful in the method pushdown + */ + private void pushdownThroughSelect(TopNKeyOperator topNKey) throws SemanticException { + + final SelectOperator select = (SelectOperator) topNKey.getParentOperators().get(0); + final TopNKeyDesc topNKeyDesc = topNKey.getConf(); + + final List mappedColumns = mapColumns(topNKeyDesc.getKeyColumns(), select.getColumnExprMap()); + if (mappedColumns.size() != topNKeyDesc.getKeyColumns().size()) { + return; + } + + LOG.debug("Pushing {} through {}", topNKey.getName(), select.getName()); + topNKeyDesc.setKeyColumns(mappedColumns); + moveDown(topNKey); + pushdown(topNKey); + } + + private static List mapColumns(List columns, Map + colExprMap) { + + if (colExprMap == null) { + return new ArrayList<>(0); + } + final List mappedColumns = new ArrayList<>(); + for (ExprNodeDesc column : columns) { + final String columnName = column.getExprString(); + if (colExprMap.containsKey(columnName)) { + mappedColumns.add(colExprMap.get(columnName)); + } + } + return mappedColumns; + } + + private void pushdownThroughParent(TopNKeyOperator topNKey) throws SemanticException { + Operator parent = topNKey.getParentOperators().get(0); + LOG.debug("Pushing {} through {}", topNKey.getName(), parent.getName()); + moveDown(topNKey); + pushdown(topNKey); + } + + /** + * Push through GroupBy. No grouping sets. If TopNKey expression is same as GroupBy expression, + * we can push it and remove it from above GroupBy. If expression in TopNKey shared common + * prefix with GroupBy, TopNKey could be pushed through GroupBy using that prefix and kept above + * it. + * + * @param topNKey TopNKey operator to push + * @throws SemanticException when removeChildAndAdoptItsChildren was not successful + */ + private void pushdownThroughGroupBy(TopNKeyOperator topNKey) throws SemanticException { + final GroupByOperator groupBy = (GroupByOperator) topNKey.getParentOperators().get(0); + final GroupByDesc groupByDesc = groupBy.getConf(); + final TopNKeyDesc topNKeyDesc = topNKey.getConf(); + + // Check grouping sets + if (groupByDesc.isGroupingSetsPresent()) { + return; + } + + CommonKeyPrefix commonKeyPrefix = CommonKeyPrefix.map(topNKeyDesc, groupByDesc); + if (commonKeyPrefix.isEmpty()) { + return; + } + + LOG.debug("Pushing a copy of {} through {}", topNKey.getName(), groupBy.getName()); + final TopNKeyDesc newTopNKeyDesc = new TopNKeyDesc(topNKeyDesc.getTopN(), commonKeyPrefix.getMappedOrder(), + commonKeyPrefix.getMappedNullOrder(), commonKeyPrefix.getMappedColumns()); + pushdown(copyDown(groupBy, newTopNKeyDesc)); + + if (topNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size()) { + LOG.debug("Removing {} above {}", topNKey.getName(), groupBy.getName()); + groupBy.removeChildAndAdoptItsChildren(topNKey); + } + } + + /** + * Push through ReduceSink. If TopNKey expression is same as ReduceSink expression and order is + * the same, we can push it and remove it from above ReduceSink. If expression in TopNKey shared + * common prefix with ReduceSink including same order, TopNKey could be pushed through + * ReduceSink using that prefix and kept above it. + * + * @param topNKey TopNKey operator to push + * @throws SemanticException when removeChildAndAdoptItsChildren was not successful + */ + private void pushdownThroughReduceSink(TopNKeyOperator topNKey) throws SemanticException { + ReduceSinkOperator reduceSink = (ReduceSinkOperator) topNKey.getParentOperators().get(0); + final ReduceSinkDesc reduceSinkDesc = reduceSink.getConf(); + final TopNKeyDesc topNKeyDesc = topNKey.getConf(); + + CommonKeyPrefix commonKeyPrefix = CommonKeyPrefix.map(topNKeyDesc, reduceSinkDesc); + if (commonKeyPrefix.isEmpty()) { + return; + } + + LOG.debug("Pushing a copy of {} through {}", topNKey.getName(), reduceSink.getName()); + final TopNKeyDesc newTopNKeyDesc = new TopNKeyDesc(topNKeyDesc.getTopN(), + commonKeyPrefix.getMappedOrder(), commonKeyPrefix.getMappedNullOrder(), commonKeyPrefix.getMappedColumns()); + pushdown(copyDown(reduceSink, newTopNKeyDesc)); + + if (topNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size()) { + LOG.debug("Removing {} above {}", topNKey.getName(), reduceSink.getName()); + reduceSink.removeChildAndAdoptItsChildren(topNKey); + } + } + + // Only push down through Left Outer Join is supported. + // Right and Full Outer Join support will be added in a follow up patch. + private void pushDownThroughJoin(TopNKeyOperator topNKey) + throws SemanticException { + CommonJoinOperator parent = + (CommonJoinOperator) topNKey.getParentOperators().get(0); + JoinCondDesc[] joinConds = parent.getConf().getConds(); + JoinCondDesc firstJoinCond = joinConds[0]; + for (JoinCondDesc joinCond : joinConds) { + if (!firstJoinCond.equals(joinCond)) { + return; + } + } + if (firstJoinCond.getType() == JoinDesc.LEFT_OUTER_JOIN) { + pushdownThroughLeftOuterJoin(topNKey); + } + } + + /** + * Push through LOJ. If TopNKey expression refers fully to expressions from left input, push + * with rewriting of expressions and remove from top of LOJ. If TopNKey expression has a prefix + * that refers to expressions from left input, push with rewriting of those expressions and keep + * on top of LOJ. + * + * @param topNKey TopNKey operator to push + * @throws SemanticException when removeChildAndAdoptItsChildren was not successful + */ + private void pushdownThroughLeftOuterJoin(TopNKeyOperator topNKey) throws SemanticException { + final TopNKeyDesc topNKeyDesc = topNKey.getConf(); + final CommonJoinOperator join = + (CommonJoinOperator) topNKey.getParentOperators().get(0); + final List> joinInputs = join.getParentOperators(); + final ReduceSinkOperator reduceSinkOperator = (ReduceSinkOperator) joinInputs.get(0); + final ReduceSinkDesc reduceSinkDesc = reduceSinkOperator.getConf(); + + CommonKeyPrefix commonKeyPrefix = CommonKeyPrefix.map( + mapUntilColumnEquals(topNKeyDesc.getKeyColumns(), join.getColumnExprMap()), + topNKeyDesc.getColumnSortOrder(), + topNKeyDesc.getNullOrder(), + reduceSinkDesc.getKeyCols(), + reduceSinkDesc.getColumnExprMap(), + reduceSinkDesc.getOrder(), + reduceSinkDesc.getNullOrder()); + if (commonKeyPrefix.isEmpty()) { + return; + } + + LOG.debug("Pushing a copy of {} through {} and {}", + topNKey.getName(), join.getName(), reduceSinkOperator.getName()); + final TopNKeyDesc newTopNKeyDesc = new TopNKeyDesc(topNKeyDesc.getTopN(), + commonKeyPrefix.getMappedOrder(), commonKeyPrefix.getMappedNullOrder(), commonKeyPrefix.getMappedColumns()); + pushdown(copyDown(reduceSinkOperator, newTopNKeyDesc)); + + if (topNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size()) { + LOG.debug("Removing {} above {}", topNKey.getName(), join.getName()); + join.removeChildAndAdoptItsChildren(topNKey); + } + } + + private List mapUntilColumnEquals(List columns, Map colExprMap) { + if (colExprMap == null) { + return new ArrayList<>(0); + } + final List mappedColumns = new ArrayList<>(); + for (ExprNodeDesc column : columns) { + final String columnName = column.getExprString(); + if (colExprMap.containsKey(columnName)) { + mappedColumns.add(colExprMap.get(columnName)); + } else { + return mappedColumns; + } + } + return mappedColumns; + } + + /** + * Push through another Top N Key operator. + * If the TNK operators are the same one of them will be removed. See {@link TopNKeyDesc#isSame} + * else If expression in topnKey is a common prefix in it's parent TNK op and topN property is same + * then topnkey could be pushed through parent. + * If the Top N Key operator can not be pushed through this method tries to remove one of them: + * - if topN property is the same and the keys of one of the operators are subset of the other then the operator + * can be removed + * - if the keys are the same operator with higher topN value can be removed + * @param topNKey TopNKey operator to push + * @throws SemanticException when removeChildAndAdoptItsChildren was not successful + */ + private void pushdownThroughTopNKey(TopNKeyOperator topNKey) throws SemanticException { + TopNKeyOperator parent = (TopNKeyOperator) topNKey.getParentOperators().get(0); + if (hasSameTopNKeyDesc(parent, topNKey.getConf())) { + LOG.debug("Removing {} above same operator: {}", topNKey.getName(), parent.getName()); + parent.removeChildAndAdoptItsChildren(topNKey); + return; + } + + TopNKeyDesc topNKeyDesc = topNKey.getConf(); + TopNKeyDesc parentTopNKeyDesc = parent.getConf(); + CommonKeyPrefix commonKeyPrefix = CommonKeyPrefix.map( + topNKeyDesc.getKeyColumns(), topNKeyDesc.getColumnSortOrder(), topNKeyDesc.getNullOrder(), + parentTopNKeyDesc.getKeyColumns(), parentTopNKeyDesc.getColumnSortOrder(), + parentTopNKeyDesc.getNullOrder()); + + if (topNKeyDesc.getTopN() == parentTopNKeyDesc.getTopN()) { + if (topNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size()) { + // TNK keys are subset of the parent TNK keys + pushdownThroughParent(topNKey); + if (topNKey.getChildOperators().get(0).getType() == OperatorType.TOPNKEY) { + LOG.debug("Removing {} since child {} supersedes it", parent.getName(), topNKey.getName()); + topNKey.getParentOperators().get(0).removeChildAndAdoptItsChildren(topNKey); + } + } else if (parentTopNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size()) { + // parent TNK keys are subset of TNK keys + LOG.debug("Removing parent of {} since it supersedes", topNKey.getName()); + parent.getParentOperators().get(0).removeChildAndAdoptItsChildren(parent); + } + } else if (topNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size() && + parentTopNKeyDesc.getKeyColumns().size() == commonKeyPrefix.size()) { + if (topNKeyDesc.getTopN() > parentTopNKeyDesc.getTopN()) { + LOG.debug("Removing {}. Parent {} has same keys but lower topN {} > {}", + topNKey.getName(), parent.getName(), topNKeyDesc.getTopN(), parentTopNKeyDesc.getTopN()); + topNKey.getParentOperators().get(0).removeChildAndAdoptItsChildren(topNKey); + } else { + LOG.debug("Removing parent {}. {} has same keys but lower topN {} < {}", + parent.getName(), topNKey.getName(), topNKeyDesc.getTopN(), parentTopNKeyDesc.getTopN()); + parent.getParentOperators().get(0).removeChildAndAdoptItsChildren(parent); + } + } + } + + private static boolean hasSameTopNKeyDesc(Operator operator, TopNKeyDesc desc) { + if (!(operator instanceof TopNKeyOperator)) { + return false; + } + + final TopNKeyOperator topNKey = (TopNKeyOperator) operator; + final TopNKeyDesc opDesc = topNKey.getConf(); + return opDesc.isSame(desc); + } + + private static void moveDown(TopNKeyOperator topNKey) throws SemanticException { + + assert topNKey.getNumParent() == 1; + final Operator parent = topNKey.getParentOperators().get(0); + final List> grandParents = parent.getParentOperators(); + parent.removeChildAndAdoptItsChildren(topNKey); + for (Operator grandParent : grandParents) { + grandParent.replaceChild(parent, topNKey); + } + topNKey.getParentOperators().clear(); + topNKey.getParentOperators().addAll(grandParents); + + topNKey.getChildOperators().clear(); + topNKey.getChildOperators().add(parent); + + parent.getParentOperators().clear(); + parent.getParentOperators().add(topNKey); + } +} diff --git ql/src/java/org/apache/hadoop/hive/ql/parse/TezCompiler.java ql/src/java/org/apache/hadoop/hive/ql/parse/TezCompiler.java index 5c7a64c950..ff815434f0 100644 --- ql/src/java/org/apache/hadoop/hive/ql/parse/TezCompiler.java +++ ql/src/java/org/apache/hadoop/hive/ql/parse/TezCompiler.java @@ -19,7 +19,6 @@ import com.google.common.collect.ListMultimap; import com.google.common.collect.Sets; -import java.io.Serializable; import java.util.ArrayList; import java.util.Collection; import java.util.Comparator; @@ -63,6 +62,7 @@ import org.apache.hadoop.hive.ql.exec.Task; import org.apache.hadoop.hive.ql.exec.TerminalOperator; import org.apache.hadoop.hive.ql.exec.TezDummyStoreOperator; +import org.apache.hadoop.hive.ql.exec.TopNKeyOperator; import org.apache.hadoop.hive.ql.exec.UnionOperator; import org.apache.hadoop.hive.ql.exec.tez.TezTask; import org.apache.hadoop.hive.ql.hooks.ReadEntity; @@ -93,9 +93,10 @@ import org.apache.hadoop.hive.ql.optimizer.SetReducerParallelism; import org.apache.hadoop.hive.ql.optimizer.SharedWorkOptimizer; import org.apache.hadoop.hive.ql.optimizer.SortedDynPartitionOptimizer; -import org.apache.hadoop.hive.ql.optimizer.TopNKeyProcessor; +import org.apache.hadoop.hive.ql.optimizer.topnkey.TopNKeyProcessor; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveFilter; import org.apache.hadoop.hive.ql.optimizer.correlation.ReduceSinkDeDuplication; +import org.apache.hadoop.hive.ql.optimizer.topnkey.TopNKeyPushdownProcessor; import org.apache.hadoop.hive.ql.optimizer.correlation.ReduceSinkJoinDeDuplication; import org.apache.hadoop.hive.ql.optimizer.metainfo.annotation.AnnotateWithOpTraits; import org.apache.hadoop.hive.ql.optimizer.physical.AnnotateRunTimeStatsOptimizer; @@ -1288,9 +1289,12 @@ private static void runTopNKeyOptimization(OptimizeTezProcContext procCtx) Map opRules = new LinkedHashMap(); opRules.put( - new RuleRegExp("Top n key optimization", GroupByOperator.getOperatorName() + "%" + - ReduceSinkOperator.getOperatorName() + "%"), + new RuleRegExp("Top n key optimization", ReduceSinkOperator.getOperatorName() + "%"), new TopNKeyProcessor()); + opRules.put( + new RuleRegExp("Top n key pushdown", TopNKeyOperator.getOperatorName() + "%"), + new TopNKeyPushdownProcessor()); + // The dispatcher fires the processor corresponding to the closest matching // rule and passes the context along diff --git ql/src/test/org/apache/hadoop/hive/ql/optimizer/topnkey/TestCommonKeyPrefix.java ql/src/test/org/apache/hadoop/hive/ql/optimizer/topnkey/TestCommonKeyPrefix.java new file mode 100644 index 0000000000..51d2382278 --- /dev/null +++ ql/src/test/org/apache/hadoop/hive/ql/optimizer/topnkey/TestCommonKeyPrefix.java @@ -0,0 +1,185 @@ +/* + * 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.topnkey; + +import static java.util.Arrays.asList; +import static java.util.Collections.singletonList; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.Is.is; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Map; + +import org.apache.hadoop.hive.ql.plan.ExprNodeColumnDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; +import org.junit.Test; + +/** + * Tests for CommonKeyPrefix. + */ +public class TestCommonKeyPrefix { + + @Test + public void testmapWhenNoKeysExists() { + // when + CommonKeyPrefix commonPrefix = CommonKeyPrefix.map( + new ArrayList<>(0), "", "", new ArrayList<>(0), new HashMap<>(0), "", ""); + // then + assertThat(commonPrefix.isEmpty(), is(true)); + assertThat(commonPrefix.size(), is(0)); + assertThat(commonPrefix.getMappedOrder(), is("")); + assertThat(commonPrefix.getMappedNullOrder(), is("")); + assertThat(commonPrefix.getMappedColumns().isEmpty(), is(true)); + } + + @Test + public void testmapWhenAllKeysMatch() { + // given + ExprNodeColumnDesc childCol0 = exprNodeColumnDesc("_col0"); + ExprNodeColumnDesc childCol1 = exprNodeColumnDesc("_col1"); + ExprNodeColumnDesc parentCol0 = exprNodeColumnDesc("KEY._col0"); + ExprNodeColumnDesc parentCol1 = exprNodeColumnDesc("KEY._col1"); + Map exprNodeDescMap = new HashMap<>(); + exprNodeDescMap.put("_col0", parentCol0); + exprNodeDescMap.put("_col1", parentCol1); + + // when + CommonKeyPrefix commonPrefix = CommonKeyPrefix.map( + asList(childCol0, childCol1), "++", "aa", asList(parentCol0, parentCol1), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(false)); + assertThat(commonPrefix.size(), is(2)); + assertThat(commonPrefix.getMappedOrder(), is("++")); + assertThat(commonPrefix.getMappedNullOrder(), is("aa")); + assertThat(commonPrefix.getMappedColumns().get(0), is(parentCol0)); + assertThat(commonPrefix.getMappedColumns().get(1), is(parentCol1)); + } + + private ExprNodeColumnDesc exprNodeColumnDesc(String colName) { + ExprNodeColumnDesc exprNodeColumnDesc = new ExprNodeColumnDesc(); + exprNodeColumnDesc.setColumn(colName); + exprNodeColumnDesc.setTypeInfo(TypeInfoFactory.intTypeInfo); + return exprNodeColumnDesc; + } + + @Test + public void testmapWhenOnlyFirstKeyMatchFromTwo() { + // given + ExprNodeColumnDesc childCol0 = exprNodeColumnDesc("_col0"); + ExprNodeColumnDesc differentChildCol = exprNodeColumnDesc("_col2"); + ExprNodeColumnDesc parentCol0 = exprNodeColumnDesc("KEY._col0"); + ExprNodeColumnDesc parentCol1 = exprNodeColumnDesc("KEY._col1"); + Map exprNodeDescMap = new HashMap<>(); + exprNodeDescMap.put("_col0", parentCol0); + exprNodeDescMap.put("_col1", parentCol1); + + // when + CommonKeyPrefix commonPrefix = CommonKeyPrefix.map( + asList(childCol0, differentChildCol), "++", "aa", + asList(parentCol0, parentCol1), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(false)); + assertThat(commonPrefix.size(), is(1)); + assertThat(commonPrefix.getMappedOrder(), is("+")); + assertThat(commonPrefix.getMappedColumns().get(0), is(parentCol0)); + } + + @Test + public void testmapWhenAllColumnsMatchButOrderMismatch() { + // given + ExprNodeColumnDesc childCol0 = exprNodeColumnDesc("_col0"); + ExprNodeColumnDesc childCol1 = exprNodeColumnDesc("_col1"); + ExprNodeColumnDesc parentCol0 = exprNodeColumnDesc("KEY._col0"); + ExprNodeColumnDesc parentCol1 = exprNodeColumnDesc("KEY._col1"); + Map exprNodeDescMap = new HashMap<>(); + exprNodeDescMap.put("_col0", parentCol0); + exprNodeDescMap.put("_col1", parentCol1); + + // when + CommonKeyPrefix commonPrefix = CommonKeyPrefix.map( + asList(childCol0, childCol1), "+-", "aa", asList(parentCol0, parentCol1), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(false)); + assertThat(commonPrefix.size(), is(1)); + assertThat(commonPrefix.getMappedOrder(), is("+")); + assertThat(commonPrefix.getMappedNullOrder(), is("a")); + assertThat(commonPrefix.getMappedColumns().get(0), is(parentCol0)); + + // when + commonPrefix = CommonKeyPrefix.map( + asList(childCol0, childCol1), "-+", "aa", asList(parentCol0, parentCol1), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(true)); + } + + @Test + public void testmapWhenAllColumnsMatchButNullOrderMismatch() { + // given + ExprNodeColumnDesc childCol0 = exprNodeColumnDesc("_col0"); + ExprNodeColumnDesc childCol1 = exprNodeColumnDesc("_col1"); + ExprNodeColumnDesc parentCol0 = exprNodeColumnDesc("KEY._col0"); + ExprNodeColumnDesc parentCol1 = exprNodeColumnDesc("KEY._col1"); + Map exprNodeDescMap = new HashMap<>(); + exprNodeDescMap.put("_col0", parentCol0); + exprNodeDescMap.put("_col1", parentCol1); + + // when + CommonKeyPrefix commonPrefix = CommonKeyPrefix.map( + asList(childCol0, childCol1), "++", "az", asList(parentCol0, parentCol1), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(false)); + assertThat(commonPrefix.size(), is(1)); + assertThat(commonPrefix.getMappedOrder(), is("+")); + assertThat(commonPrefix.getMappedNullOrder(), is("a")); + assertThat(commonPrefix.getMappedColumns().get(0), is(parentCol0)); + + // when + commonPrefix = CommonKeyPrefix.map( + asList(childCol0, childCol1), "++", "za", asList(parentCol0, parentCol1), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(true)); + } + + @Test + public void testmapWhenKeyCountsMismatch() { + // given + ExprNodeColumnDesc childCol0 = exprNodeColumnDesc("_col0"); + ExprNodeColumnDesc childCol1 = exprNodeColumnDesc("_col1"); + ExprNodeColumnDesc parentCol0 = exprNodeColumnDesc("KEY._col0"); + Map exprNodeDescMap = new HashMap<>(); + exprNodeDescMap.put("_col0", parentCol0); + + // when + CommonKeyPrefix commonPrefix = CommonKeyPrefix.map( + asList(childCol0, childCol1), "++", "aa", singletonList(parentCol0), exprNodeDescMap, "++", "aa"); + + // then + assertThat(commonPrefix.isEmpty(), is(false)); + assertThat(commonPrefix.size(), is(1)); + assertThat(commonPrefix.getMappedOrder(), is("+")); + assertThat(commonPrefix.getMappedColumns().get(0), is(parentCol0)); + } +} diff --git ql/src/test/queries/clientpositive/topnkey.q ql/src/test/queries/clientpositive/topnkey.q index 057b6a45ba..6b53d6c6b1 100644 --- ql/src/test/queries/clientpositive/topnkey.q +++ ql/src/test/queries/clientpositive/topnkey.q @@ -1,30 +1,68 @@ --! qt:dataset:src -set hive.mapred.mode=nonstrict; -set hive.vectorized.execution.enabled=false; -set hive.optimize.topnkey=true; - -set hive.optimize.ppd=true; -set hive.ppd.remove.duplicatefilters=true; -set hive.tez.dynamic.partition.pruning=true; -set hive.optimize.metadataonly=false; -set hive.optimize.index.filter=true; -set hive.tez.min.bloom.filter.entries=1; - -set hive.tez.dynamic.partition.pruning=true; -set hive.stats.fetch.column.stats=true; -set hive.cbo.enable=true; - -EXPLAIN EXTENDED +SET hive.mapred.mode=nonstrict; +SET hive.vectorized.execution.enabled=false; +SET hive.optimize.topnkey=true; + +SET hive.optimize.ppd=true; +SET hive.ppd.remove.duplicatefilters=true; +SET hive.tez.dynamic.partition.pruning=true; +SET hive.optimize.metadataonly=false; +SET hive.optimize.index.filter=true; +SET hive.tez.min.bloom.filter.entries=1; + +SET hive.stats.fetch.column.stats=true; +SET hive.cbo.enable=true; + +SET hive.optimize.topnkey=true; +EXPLAIN +SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5; SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5; +SET hive.optimize.topnkey=false; SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5; +SET hive.optimize.topnkey=true; +EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5; +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5; + +SET hive.optimize.topnkey=false; +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5; + +SET hive.optimize.topnkey=true; EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5; +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5; +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5; -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5; +SET hive.optimize.topnkey=false; +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5; + +CREATE TABLE t_test( + a int, + b int, + c int +); + +INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2); + +SET hive.optimize.topnkey=true; +EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3; +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3; + +SET hive.optimize.topnkey=false; +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3; + +SET hive.optimize.topnkey=true; +EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3; +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3; -explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5; +SET hive.optimize.topnkey=false; +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3; -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5; +DROP TABLE t_test; diff --git ql/src/test/queries/clientpositive/vector_topnkey.q ql/src/test/queries/clientpositive/vector_topnkey.q index 85c5880cd6..3412aba9db 100644 --- ql/src/test/queries/clientpositive/vector_topnkey.q +++ ql/src/test/queries/clientpositive/vector_topnkey.q @@ -43,4 +43,4 @@ SELECT cint1, cdouble FROM t_test GROUP BY cint1, cdouble ORDER BY cint1, cdoubl SELECT cvarchar, cdouble FROM t_test GROUP BY cvarchar, cdouble ORDER BY cvarchar, cdouble LIMIT 3; SELECT cdecimal1, cdecimal2 FROM t_test GROUP BY cdecimal1, cdecimal2 ORDER BY cdecimal1, cdecimal2 LIMIT 3; -DROP TABLE t_test; \ No newline at end of file +DROP TABLE t_test; diff --git ql/src/test/results/clientpositive/druid/druidmini_expressions.q.out ql/src/test/results/clientpositive/druid/druidmini_expressions.q.out index 31862546b0..9d8364012b 100644 --- ql/src/test/results/clientpositive/druid/druidmini_expressions.q.out +++ ql/src/test/results/clientpositive/druid/druidmini_expressions.q.out @@ -378,16 +378,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1968-01-01T08:00:00.000Z/1970-04-01T08:00:00.001Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -476,16 +482,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1968-01-01T08:00:00.000Z/1970-04-01T08:00:00.001Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -1285,16 +1297,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/3000-01-01T00:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -1364,16 +1382,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/3000-01-01T00:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"timestamp_parse(timestamp_format(\"__time\",'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','US/Pacific'),'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','UTC')","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -1840,17 +1864,23 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/3000-01-01T00:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"timestamp_shift(timestamp_floor(timestamp_parse(timestamp_format(\"__time\",'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','US/Pacific'),'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','UTC'),'P1D','','UTC'),'P1D',CAST((\"cdouble\" / 1000), 'LONG'),'UTC')","outputType":"LONG"},{"type":"expression","name":"vc0","expression":"timestamp_shift(timestamp_floor(timestamp_parse(timestamp_format(\"__time\",'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','US/Pacific'),'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','UTC'),'P1D','','UTC'),'P1D',-( CAST((\"cdouble\" / 1000), 'LONG') ),'UTC')","outputType":"LONG"},{"type":"expression","name":"vc1","expression":"timestamp_floor(timestamp_parse(timestamp_format(\"__time\",'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','US/Pacific'),'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','UTC'),'P1D','','UTC')","outputType":"LONG"},{"type":"expression","name":"vc2","expression":"CAST((\"cdouble\" / 1000), 'LONG')","outputType":"LONG"}],"columns":["vc","vc0","vc1","vc2"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 1499152 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: date), vc0 (type: date), vc1 (type: date), vc2 (type: int) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: ++ + keys: vc (type: date), vc0 (type: date) + null sort order: zz Statistics: Num rows: 9173 Data size: 1499152 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: date), _col1 (type: date) - null sort order: zz - sort order: ++ + top n: 3 + Select Operator + expressions: vc (type: date), vc0 (type: date), vc1 (type: date), vc2 (type: int) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 9173 Data size: 1499152 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col2 (type: date), _col3 (type: int) + Reduce Output Operator + key expressions: _col0 (type: date), _col1 (type: date) + null sort order: zz + sort order: ++ + Statistics: Num rows: 9173 Data size: 1499152 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col2 (type: date), _col3 (type: int) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -2310,16 +2340,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/3000-01-01T00:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -2389,16 +2425,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/3000-01-01T00:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"timestamp_parse(timestamp_format(\"__time\",'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','US/Pacific'),'yyyy-MM-dd\\u0027T\\u0027HH:mm:ss.SSS\\u0027Z\\u0027','UTC')","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/druid/druidmini_test1.q.out ql/src/test/results/clientpositive/druid/druidmini_test1.q.out index fe75ddd894..df37c58936 100644 --- ql/src/test/results/clientpositive/druid/druidmini_test1.q.out +++ ql/src/test/results/clientpositive/druid/druidmini_test1.q.out @@ -284,16 +284,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/3000-01-01T00:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -376,16 +382,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1900-01-01T00:00:00.000Z/1970-03-01T08:00:00.000Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -470,16 +482,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1968-01-01T08:00:00.000Z/1970-03-01T08:00:00.001Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -566,16 +584,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1968-01-01T08:00:00.000Z/1970-03-01T08:00:00.001Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -662,16 +686,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1968-01-01T08:00:00.000Z/1970-01-01T08:00:00.001Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -758,16 +788,22 @@ STAGE PLANS: druid.query.json {"queryType":"scan","dataSource":"default.druid_table_alltypesorc","intervals":["1968-01-01T08:00:00.000Z/1970-04-01T08:00:00.001Z"],"virtualColumns":[{"type":"expression","name":"vc","expression":"\"__time\"","outputType":"LONG"}],"columns":["vc"],"resultFormat":"compactedList"} druid.query.type scan Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: vc (type: timestamp with local time zone) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: vc (type: timestamp with local time zone) + null sort order: z Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: timestamp with local time zone) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: vc (type: timestamp with local time zone) + outputColumnNames: _col0 Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: timestamp with local time zone) + null sort order: z + sort order: + + Statistics: Num rows: 9173 Data size: 348640 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/bucket_groupby.q.out ql/src/test/results/clientpositive/llap/bucket_groupby.q.out index 0c051c926b..3b9274d9c6 100644 --- ql/src/test/results/clientpositive/llap/bucket_groupby.q.out +++ ql/src/test/results/clientpositive/llap/bucket_groupby.q.out @@ -70,16 +70,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '100') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: key (type: string) @@ -213,16 +213,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '101') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: key (type: string) @@ -330,16 +330,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '101') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: length(key) (type: int) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: length(key) (type: int) + null sort order: a Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: a + top n: 10 + Select Operator + expressions: length(key) (type: int) + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: _col0 (type: int) @@ -426,16 +426,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '101') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: abs(length(key)) (type: int) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: abs(length(key)) (type: int) + null sort order: a Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: a + top n: 10 + Select Operator + expressions: abs(length(key)) (type: int) + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: _col0 (type: int) @@ -523,16 +523,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '101') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: key (type: string) @@ -641,16 +641,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '101') (type: boolean) Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string) - outputColumnNames: value + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: value (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: value (type: string) + outputColumnNames: value Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: value (type: string) @@ -1277,16 +1277,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '102') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() bucketGroup: true @@ -1396,16 +1396,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '102') (type: boolean) Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string) - outputColumnNames: value + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: value (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: value (type: string) + outputColumnNames: value Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: value (type: string) @@ -1621,16 +1621,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '103') (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: z + top n: 10 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() bucketGroup: true @@ -1740,16 +1740,16 @@ STAGE PLANS: alias: clustergroupby filterExpr: (ds = '103') (type: boolean) Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: key, value + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: za Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: ++ - keys: key (type: string), value (type: string) - null sort order: za + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: key, value Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: count() keys: key (type: string), value (type: string) diff --git ql/src/test/results/clientpositive/llap/bucketmapjoin7.q.out ql/src/test/results/clientpositive/llap/bucketmapjoin7.q.out index 53e57b892f..242fc8eb08 100644 --- ql/src/test/results/clientpositive/llap/bucketmapjoin7.q.out +++ ql/src/test/results/clientpositive/llap/bucketmapjoin7.q.out @@ -253,19 +253,25 @@ STAGE PLANS: outputColumnNames: _col0, _col8 Position of Big Table: 1 Statistics: Num rows: 72 Data size: 29216 Basic stats: PARTIAL Column stats: NONE - Select Operator - expressions: _col0 (type: int), _col8 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: _col0 (type: int), _col8 (type: string) + null sort order: zz Statistics: Num rows: 72 Data size: 29216 Basic stats: PARTIAL Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: string) - null sort order: zz - sort order: ++ + top n: 1 + Select Operator + expressions: _col0 (type: int), _col8 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 72 Data size: 29216 Basic stats: PARTIAL Column stats: NONE - tag: -1 - TopN: 1 - TopN Hash Memory Usage: 0.1 - auto parallelism: false + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 72 Data size: 29216 Basic stats: PARTIAL Column stats: NONE + tag: -1 + TopN: 1 + TopN Hash Memory Usage: 0.1 + auto parallelism: false Reducer 3 Execution mode: llap Needs Tagging: false diff --git ql/src/test/results/clientpositive/llap/check_constraint.q.out ql/src/test/results/clientpositive/llap/check_constraint.q.out index 9f2c9a1cd0..0f72ac2c1b 100644 --- ql/src/test/results/clientpositive/llap/check_constraint.q.out +++ ql/src/test/results/clientpositive/llap/check_constraint.q.out @@ -1455,17 +1455,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: UDFToInteger(key) (type: int), CAST( key AS decimal(5,2)) (type: decimal(5,2)), value (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 500 Data size: 103500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: UDFToInteger(key) (type: int) + null sort order: z + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Select Operator + expressions: UDFToInteger(key) (type: int), CAST( key AS decimal(5,2)) (type: decimal(5,2)), value (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 103500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: decimal(5,2)), _col2 (type: string) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 103500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: decimal(5,2)), _col2 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -1752,16 +1758,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string), UDFToInteger(key) (type: int), CAST( key AS decimal(5,2)) (type: decimal(5,2)) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: zz Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: ++ - keys: _col0 (type: string), _col1 (type: string) - null sort order: zz + top n: 10 + Select Operator + expressions: key (type: string), value (type: string), UDFToInteger(key) (type: int), CAST( key AS decimal(5,2)) (type: decimal(5,2)) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator aggregations: min(_col2), max(_col3) keys: _col0 (type: string), _col1 (type: string) @@ -3454,17 +3460,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: string) - null sort order: z - sort order: + + top n: 3 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string) + Reduce Output Operator + key expressions: _col1 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/constraints_optimization.q.out ql/src/test/results/clientpositive/llap/constraints_optimization.q.out index b6d210becf..6de1d487f5 100644 --- ql/src/test/results/clientpositive/llap/constraints_optimization.q.out +++ ql/src/test/results/clientpositive/llap/constraints_optimization.q.out @@ -187,16 +187,22 @@ STAGE PLANS: Filter Operator predicate: (d_year) IN (1985, 2004) (type: boolean) Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: d_datekey (type: bigint) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: d_datekey (type: bigint) + null sort order: z Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: bigint) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: d_datekey (type: bigint) + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: bigint) + null sort order: z + sort order: + + Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -256,16 +262,22 @@ STAGE PLANS: Filter Operator predicate: (d_year) IN (1985, 2004) (type: boolean) Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: d_datekey (type: bigint) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: d_datekey (type: bigint) + null sort order: z Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: bigint) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: d_datekey (type: bigint) + outputColumnNames: _col0 Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: bigint) + null sort order: z + sort order: + + Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -326,16 +338,16 @@ STAGE PLANS: Filter Operator predicate: (d_year) IN (1985, 2004) (type: boolean) Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: d_datekey (type: bigint), d_id (type: bigint) - outputColumnNames: d_datekey, d_id + Top N Key Operator + sort order: ++ + keys: d_datekey (type: bigint), d_id (type: bigint) + null sort order: za Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: ++ - keys: d_datekey (type: bigint), d_id (type: bigint) - null sort order: za + top n: 10 + Select Operator + expressions: d_datekey (type: bigint), d_id (type: bigint) + outputColumnNames: d_datekey, d_id Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE - top n: 10 Group By Operator aggregations: count() keys: d_datekey (type: bigint), d_id (type: bigint) @@ -594,16 +606,16 @@ STAGE PLANS: Filter Operator predicate: (d_year) IN (1985, 2004) (type: boolean) Statistics: Num rows: 1 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: d_datekey (type: bigint), d_sellingseason (type: string) - outputColumnNames: d_datekey, d_sellingseason + Top N Key Operator + sort order: ++ + keys: d_datekey (type: bigint), d_sellingseason (type: string) + null sort order: za Statistics: Num rows: 1 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: ++ - keys: d_datekey (type: bigint), d_sellingseason (type: string) - null sort order: za + top n: 10 + Select Operator + expressions: d_datekey (type: bigint), d_sellingseason (type: string) + outputColumnNames: d_datekey, d_sellingseason Statistics: Num rows: 1 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 Group By Operator keys: d_datekey (type: bigint), d_sellingseason (type: string) minReductionHashAggr: 0.0 diff --git ql/src/test/results/clientpositive/llap/ctas.q.out ql/src/test/results/clientpositive/llap/ctas.q.out index c10d75d081..275bebd3b9 100644 --- ql/src/test/results/clientpositive/llap/ctas.q.out +++ ql/src/test/results/clientpositive/llap/ctas.q.out @@ -46,16 +46,22 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: zz Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: ++ + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -68,12 +74,18 @@ STAGE PLANS: Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -245,16 +257,22 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: zz Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: ++ + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -267,12 +285,18 @@ STAGE PLANS: Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -444,16 +468,22 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: (key / 2) (type: double), concat(value, '_con') (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double), _col1 (type: string) - null sort order: zz - sort order: ++ + Top N Key Operator + sort order: ++ + keys: (key / 2) (type: double), concat(value, '_con') (type: string) + null sort order: zz + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Select Operator + expressions: (key / 2) (type: double), concat(value, '_con') (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: double), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -466,12 +496,18 @@ STAGE PLANS: Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 1920 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double), _col1 (type: string) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col0 (type: double), _col1 (type: string) + null sort order: zz Statistics: Num rows: 10 Data size: 1920 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: double), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 10 Data size: 1920 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -707,16 +743,22 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: zz Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: ++ + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -729,12 +771,18 @@ STAGE PLANS: Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -908,16 +956,22 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: zz Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: ++ + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -930,12 +984,18 @@ STAGE PLANS: Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 10 Data size: 1780 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/dynpart_sort_opt_vectorization.q.out ql/src/test/results/clientpositive/llap/dynpart_sort_opt_vectorization.q.out index 4e62779446..7367612588 100644 --- ql/src/test/results/clientpositive/llap/dynpart_sort_opt_vectorization.q.out +++ ql/src/test/results/clientpositive/llap/dynpart_sort_opt_vectorization.q.out @@ -1842,17 +1842,23 @@ STAGE PLANS: TableScan alias: over1k_orc Statistics: Num rows: 1049 Data size: 25160 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float) - outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Top N Key Operator + sort order: + + keys: i (type: int) + null sort order: z Statistics: Num rows: 1049 Data size: 25160 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col2 (type: int) - null sort order: z - sort order: + - Statistics: Num rows: 1049 Data size: 25160 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col3 (type: bigint), _col4 (type: float) + top n: 10 + Select Operator + expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float) + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Statistics: Num rows: 1049 Data size: 25136 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col2 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 1049 Data size: 25136 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col3 (type: bigint), _col4 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs Reducer 2 @@ -1861,7 +1867,7 @@ STAGE PLANS: Select Operator expressions: VALUE._col0 (type: tinyint), VALUE._col1 (type: smallint), KEY.reducesinkkey0 (type: int), VALUE._col2 (type: bigint), VALUE._col3 (type: float) outputColumnNames: _col0, _col1, _col2, _col3, _col4 - Statistics: Num rows: 1049 Data size: 25160 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 1049 Data size: 25136 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 10 Statistics: Num rows: 10 Data size: 240 Basic stats: COMPLETE Column stats: COMPLETE diff --git ql/src/test/results/clientpositive/llap/dynpart_sort_optimization.q.out ql/src/test/results/clientpositive/llap/dynpart_sort_optimization.q.out index 6688944b78..9536543f20 100644 --- ql/src/test/results/clientpositive/llap/dynpart_sort_optimization.q.out +++ ql/src/test/results/clientpositive/llap/dynpart_sort_optimization.q.out @@ -1771,17 +1771,23 @@ STAGE PLANS: TableScan alias: over1k_n3 Statistics: Num rows: 1 Data size: 24 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float) - outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Top N Key Operator + sort order: + + keys: i (type: int) + null sort order: z Statistics: Num rows: 1 Data size: 24 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col2 (type: int) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float) + outputColumnNames: _col0, _col1, _col2, _col3, _col4 Statistics: Num rows: 1 Data size: 24 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col3 (type: bigint), _col4 (type: float) + Reduce Output Operator + key expressions: _col2 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 1 Data size: 24 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col3 (type: bigint), _col4 (type: float) Execution mode: llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/enforce_constraint_notnull.q.out ql/src/test/results/clientpositive/llap/enforce_constraint_notnull.q.out index 9343e078b7..f21abe6c13 100644 --- ql/src/test/results/clientpositive/llap/enforce_constraint_notnull.q.out +++ ql/src/test/results/clientpositive/llap/enforce_constraint_notnull.q.out @@ -2944,17 +2944,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: UDFToInteger(key) (type: int), CAST( key AS decimal(5,2)) (type: decimal(5,2)), value (type: string) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 500 Data size: 103500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: UDFToInteger(key) (type: int) + null sort order: z + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 2 + Select Operator + expressions: UDFToInteger(key) (type: int), CAST( key AS decimal(5,2)) (type: decimal(5,2)), value (type: string) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 500 Data size: 103500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: decimal(5,2)), _col2 (type: string) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 103500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: decimal(5,2)), _col2 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -3077,16 +3083,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: key, value + Top N Key Operator + sort order: ++ + keys: key (type: string), value (type: string) + null sort order: za Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: ++ - keys: key (type: string), value (type: string) - null sort order: za + top n: 2 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: key, value Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 2 Group By Operator keys: key (type: string), value (type: string) minReductionHashAggr: 0.0 @@ -6048,17 +6054,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: string) - null sort order: z - sort order: + + top n: 3 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string) + Reduce Output Operator + key expressions: _col1 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/explainuser_1.q.out ql/src/test/results/clientpositive/llap/explainuser_1.q.out index 64fdc481eb..e827cc28a2 100644 --- ql/src/test/results/clientpositive/llap/explainuser_1.q.out +++ ql/src/test/results/clientpositive/llap/explainuser_1.q.out @@ -1475,23 +1475,25 @@ Stage-0 File Output Operator [FS_9] Limit [LIM_8] (rows=1 width=97) Number of rows:1 - Select Operator [SEL_7] (rows=10 width=97) + Select Operator [SEL_7] (rows=10 width=88) Output:["_col0","_col1","_col2"] <-Reducer 2 [SIMPLE_EDGE] llap SHUFFLE [RS_6] - Select Operator [SEL_5] (rows=10 width=97) + Select Operator [SEL_5] (rows=10 width=88) Output:["_col0","_col1","_col2"] - Group By Operator [GBY_4] (rows=10 width=101) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Map 1 [SIMPLE_EDGE] llap - SHUFFLE [RS_3] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_2] (rows=10 width=101) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(c_int)"],keys:key, c_int, c_float - Select Operator [SEL_1] (rows=20 width=88) - Output:["key","c_int","c_float"] - TableScan [TS_0] (rows=20 width=88) - default@cbo_t1,cbo_t1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int","c_float"] + Top N Key Operator [TNK_10] (rows=10 width=101) + keys:((_col1 + 1) + 2),top n:1 + Group By Operator [GBY_4] (rows=10 width=101) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Map 1 [SIMPLE_EDGE] llap + SHUFFLE [RS_3] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_2] (rows=10 width=101) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(c_int)"],keys:key, c_int, c_float + Select Operator [SEL_1] (rows=20 width=88) + Output:["key","c_int","c_float"] + TableScan [TS_0] (rows=20 width=88) + default@cbo_t1,cbo_t1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int","c_float"] PREHOOK: query: explain select x, y, count(*) from (select key, (c_int+c_float+1+2) as x, sum(c_int) as y from cbo_t1 group by c_float, cbo_t1.c_int, key) R group by y, x order by x,y limit 1 PREHOOK: type: QUERY @@ -1529,10 +1531,10 @@ Stage-0 PartitionCols:_col0, _col1 Group By Operator [GBY_7] (rows=5 width=20) Output:["_col0","_col1","_col2"],aggregations:["count()"],keys:_col1, _col0 - Top N Key Operator [TNK_15] (rows=10 width=101) - keys:_col1, _col0,top n:1 - Select Operator [SEL_5] (rows=10 width=101) - Output:["_col0","_col1"] + Select Operator [SEL_5] (rows=10 width=101) + Output:["_col0","_col1"] + Top N Key Operator [TNK_18] (rows=10 width=101) + keys:(((UDFToFloat(_col1) + _col2) + 1.0) + 2.0), _col3,top n:1 Group By Operator [GBY_4] (rows=10 width=101) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Map 1 [SIMPLE_EDGE] llap @@ -1595,14 +1597,16 @@ Stage-0 SHUFFLE [RS_9] Limit [LIM_4] (rows=5 width=89) Number of rows:5 - Select Operator [SEL_3] (rows=20 width=84) + Select Operator [SEL_3] (rows=20 width=75) Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] llap SHUFFLE [RS_2] - Select Operator [SEL_1] (rows=20 width=84) + Select Operator [SEL_1] (rows=20 width=75) Output:["_col0","_col1"] - TableScan [TS_0] (rows=20 width=84) - default@cbo_t1,cbo_t1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int"] + Top N Key Operator [TNK_12] (rows=20 width=84) + keys:c_int,top n:5 + TableScan [TS_0] (rows=20 width=84) + default@cbo_t1,cbo_t1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int"] PREHOOK: query: explain select cbo_t3.c_int, c, count(*) from (select key as a, c_int+1 as b, sum(c_int) as c from cbo_t1 where (cbo_t1.c_int + 1 >= 0) and (cbo_t1.c_int > 0 or cbo_t1.c_float >= 0) group by c_float, cbo_t1.c_int, key order by a limit 5) cbo_t1 join (select key as p, c_int+1 as q, sum(c_int) as r from cbo_t2 where (cbo_t2.c_int + 1 >= 0) and (cbo_t2.c_int > 0 or cbo_t2.c_float >= 0) group by c_float, cbo_t2.c_int, key order by q/10 desc, r asc limit 5) cbo_t2 on cbo_t1.a=p join cbo_t3 on cbo_t1.a=key where (b + cbo_t2.q >= 0) and (b > 0 or c_int >= 0) group by cbo_t3.c_int, c order by cbo_t3.c_int+c desc, c limit 5 PREHOOK: type: QUERY @@ -1638,91 +1642,95 @@ Stage-0 Stage-1 Reducer 7 llap File Output Operator [FS_44] - Limit [LIM_42] (rows=1 width=28) + Limit [LIM_42] (rows=1 width=24) Number of rows:5 - Select Operator [SEL_41] (rows=1 width=28) + Select Operator [SEL_41] (rows=1 width=24) Output:["_col0","_col1","_col2"] <-Reducer 6 [SIMPLE_EDGE] llap SHUFFLE [RS_40] - Select Operator [SEL_39] (rows=1 width=28) + Select Operator [SEL_39] (rows=1 width=24) Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_38] (rows=1 width=20) - Output:["_col0","_col1","_col2"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 5 [SIMPLE_EDGE] llap - SHUFFLE [RS_37] - PartitionCols:_col0, _col1 - Group By Operator [GBY_36] (rows=1 width=20) - Output:["_col0","_col1","_col2"],aggregations:["count()"],keys:_col4, _col7 - Select Operator [SEL_35] (rows=2 width=20) - Output:["_col4","_col7"] - Merge Join Operator [MERGEJOIN_72] (rows=2 width=20) - Conds:RS_32._col2=RS_33._col0(Inner),Output:["_col4","_col5","_col7","_col8"],residual filter predicates:{(_col5 or _col8)} - <-Map 11 [SIMPLE_EDGE] llap - SHUFFLE [RS_33] - PartitionCols:_col0 - Select Operator [SEL_28] (rows=18 width=88) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_54] (rows=18 width=84) - predicate:key is not null - TableScan [TS_26] (rows=20 width=84) - default@cbo_t3,cbo_t3,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int"] - <-Reducer 4 [SIMPLE_EDGE] llap - SHUFFLE [RS_32] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_71] (rows=1 width=105) - Conds:RS_29._col0=RS_30._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"],residual filter predicates:{((_col3 + _col1) >= 0)} - <-Reducer 10 [SIMPLE_EDGE] llap - SHUFFLE [RS_30] - PartitionCols:_col0 - Select Operator [SEL_25] (rows=2 width=101) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_24] (rows=2 width=97) + Top N Key Operator [TNK_55] (rows=1 width=20) + keys:(UDFToLong(_col1) + _col0), _col0,top n:5 + Group By Operator [GBY_38] (rows=1 width=20) + Output:["_col0","_col1","_col2"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 5 [SIMPLE_EDGE] llap + SHUFFLE [RS_37] + PartitionCols:_col0, _col1 + Group By Operator [GBY_36] (rows=1 width=20) + Output:["_col0","_col1","_col2"],aggregations:["count()"],keys:_col4, _col7 + Select Operator [SEL_35] (rows=2 width=20) + Output:["_col4","_col7"] + Merge Join Operator [MERGEJOIN_79] (rows=2 width=20) + Conds:RS_32._col2=RS_33._col0(Inner),Output:["_col4","_col5","_col7","_col8"],residual filter predicates:{(_col5 or _col8)} + <-Map 11 [SIMPLE_EDGE] llap + SHUFFLE [RS_33] + PartitionCols:_col0 + Select Operator [SEL_28] (rows=18 width=88) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_54] (rows=18 width=84) + predicate:key is not null + TableScan [TS_26] (rows=20 width=84) + default@cbo_t3,cbo_t3,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int"] + <-Reducer 4 [SIMPLE_EDGE] llap + SHUFFLE [RS_32] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_78] (rows=1 width=105) + Conds:RS_29._col0=RS_30._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"],residual filter predicates:{((_col3 + _col1) >= 0)} + <-Reducer 10 [SIMPLE_EDGE] llap + SHUFFLE [RS_30] + PartitionCols:_col0 + Select Operator [SEL_25] (rows=2 width=101) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_24] (rows=2 width=97) + predicate:_col0 is not null + Limit [LIM_22] (rows=3 width=97) + Number of rows:5 + Select Operator [SEL_21] (rows=3 width=97) + Output:["_col0","_col1","_col2"] + <-Reducer 9 [SIMPLE_EDGE] llap + SHUFFLE [RS_20] + Select Operator [SEL_19] (rows=3 width=97) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_18] (rows=3 width=101) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Map 8 [SIMPLE_EDGE] llap + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_16] (rows=3 width=101) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(c_int)"],keys:key, c_int, c_float + Top N Key Operator [TNK_62] (rows=6 width=93) + keys:key, c_int, c_float,top n:5 + Filter Operator [FIL_53] (rows=6 width=93) + predicate:(((c_int > 0) or (c_float >= 0.0)) and ((c_int + 1) >= 0)) + TableScan [TS_13] (rows=20 width=88) + default@cbo_t1,cbo_t1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int","c_float"] + <-Reducer 3 [SIMPLE_EDGE] llap + SHUFFLE [RS_29] + PartitionCols:_col0 + Filter Operator [FIL_11] (rows=1 width=105) predicate:_col0 is not null - Limit [LIM_22] (rows=3 width=97) + Limit [LIM_9] (rows=3 width=76) Number of rows:5 - Select Operator [SEL_21] (rows=3 width=97) - Output:["_col0","_col1","_col2"] - <-Reducer 9 [SIMPLE_EDGE] llap - SHUFFLE [RS_20] - Select Operator [SEL_19] (rows=3 width=97) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_18] (rows=3 width=101) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Map 8 [SIMPLE_EDGE] llap - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_16] (rows=3 width=101) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(c_int)"],keys:key, c_int, c_float - Top N Key Operator [TNK_55] (rows=6 width=93) - keys:key, c_int, c_float,top n:5 - Filter Operator [FIL_53] (rows=6 width=93) + Select Operator [SEL_8] (rows=3 width=76) + Output:["_col0","_col1"] + <-Reducer 2 [SIMPLE_EDGE] llap + SHUFFLE [RS_7] + Select Operator [SEL_6] (rows=3 width=76) + Output:["_col0","_col1","_col2","_col3"] + Top N Key Operator [TNK_56] (rows=3 width=101) + keys:(UDFToDouble((_col1 + 1)) / 10.0D), _col3,top n:5 + Group By Operator [GBY_5] (rows=3 width=101) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Map 1 [SIMPLE_EDGE] llap + SHUFFLE [RS_4] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_3] (rows=3 width=101) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(c_int)"],keys:key, c_int, c_float + Filter Operator [FIL_51] (rows=6 width=93) predicate:(((c_int > 0) or (c_float >= 0.0)) and ((c_int + 1) >= 0)) - TableScan [TS_13] (rows=20 width=88) - default@cbo_t1,cbo_t1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int","c_float"] - <-Reducer 3 [SIMPLE_EDGE] llap - SHUFFLE [RS_29] - PartitionCols:_col0 - Filter Operator [FIL_11] (rows=2 width=105) - predicate:_col0 is not null - Limit [LIM_9] (rows=3 width=105) - Number of rows:5 - Select Operator [SEL_8] (rows=3 width=105) - Output:["_col0","_col1"] - <-Reducer 2 [SIMPLE_EDGE] llap - SHUFFLE [RS_7] - Select Operator [SEL_6] (rows=3 width=105) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_5] (rows=3 width=101) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Map 1 [SIMPLE_EDGE] llap - SHUFFLE [RS_4] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_3] (rows=3 width=101) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(c_int)"],keys:key, c_int, c_float - Filter Operator [FIL_51] (rows=6 width=93) - predicate:(((c_int > 0) or (c_float >= 0.0)) and ((c_int + 1) >= 0)) - TableScan [TS_0] (rows=20 width=88) - default@cbo_t2,cbo_t2,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int","c_float"] + TableScan [TS_0] (rows=20 width=88) + default@cbo_t2,cbo_t2,Tbl:COMPLETE,Col:COMPLETE,Output:["key","c_int","c_float"] PREHOOK: query: explain select cbo_t1.c_int from cbo_t1 left semi join cbo_t2 on cbo_t1.key=cbo_t2.key where (cbo_t1.c_int + 1 == 2) and (cbo_t1.c_int > 0 or cbo_t1.c_float >= 0) PREHOOK: type: QUERY @@ -3735,16 +3743,20 @@ Stage-3 Output:["_col0","_col1"] <-Reducer 2 [SIMPLE_EDGE] llap SHUFFLE [RS_5] - Limit [LIM_4] (rows=10 width=178) - Number of rows:10 - Select Operator [SEL_3] (rows=500 width=178) - Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] llap - SHUFFLE [RS_2] - Select Operator [SEL_1] (rows=500 width=178) - Output:["_col0","_col1"] - TableScan [TS_0] (rows=500 width=178) - default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] + Top N Key Operator [TNK_18] (rows=10 width=178) + keys:_col0, _col1,top n:10 + Limit [LIM_4] (rows=10 width=178) + Number of rows:10 + Select Operator [SEL_3] (rows=500 width=178) + Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] llap + SHUFFLE [RS_2] + Select Operator [SEL_1] (rows=500 width=178) + Output:["_col0","_col1"] + Top N Key Operator [TNK_19] (rows=500 width=178) + keys:key, value,top n:10 + TableScan [TS_0] (rows=500 width=178) + default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] PARTITION_ONLY_SHUFFLE [RS_14] Select Operator [SEL_13] (rows=10 width=178) Output:["col1","col2"] @@ -3802,16 +3814,20 @@ Stage-3 Output:["_col0","_col1"] <-Reducer 2 [SIMPLE_EDGE] llap SHUFFLE [RS_5] - Limit [LIM_4] (rows=10 width=192) - Number of rows:10 - Select Operator [SEL_3] (rows=500 width=192) - Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] llap - SHUFFLE [RS_2] - Select Operator [SEL_1] (rows=500 width=192) - Output:["_col0","_col1"] - TableScan [TS_0] (rows=500 width=178) - default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] + Top N Key Operator [TNK_18] (rows=10 width=192) + keys:_col0, _col1,top n:10 + Limit [LIM_4] (rows=10 width=192) + Number of rows:10 + Select Operator [SEL_3] (rows=500 width=192) + Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] llap + SHUFFLE [RS_2] + Select Operator [SEL_1] (rows=500 width=192) + Output:["_col0","_col1"] + Top N Key Operator [TNK_19] (rows=500 width=178) + keys:(key / 2), concat(value, '_con'),top n:10 + TableScan [TS_0] (rows=500 width=178) + default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] PARTITION_ONLY_SHUFFLE [RS_14] Select Operator [SEL_13] (rows=10 width=192) Output:["col1","col2"] diff --git ql/src/test/results/clientpositive/llap/explainuser_2.q.out ql/src/test/results/clientpositive/llap/explainuser_2.q.out index 0219af8833..738bf44cf8 100644 --- ql/src/test/results/clientpositive/llap/explainuser_2.q.out +++ ql/src/test/results/clientpositive/llap/explainuser_2.q.out @@ -335,123 +335,123 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized, llap - File Output Operator [FS_217] - Limit [LIM_216] (rows=2 width=285) + File Output Operator [FS_222] + Limit [LIM_221] (rows=2 width=285) Number of rows:100 - Select Operator [SEL_215] (rows=2 width=285) + Select Operator [SEL_220] (rows=2 width=285) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 4 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_214] - Group By Operator [GBY_213] (rows=2 width=285) + SHUFFLE [RS_219] + Group By Operator [GBY_218] (rows=2 width=285) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)","count(VALUE._col1)","count(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 3 [SIMPLE_EDGE] llap SHUFFLE [RS_49] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_48] (rows=2 width=285) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(_col8)","count(_col15)","count(_col3)"],keys:_col7, _col14, _col2 - Top N Key Operator [TNK_91] (rows=28 width=534) + Top N Key Operator [TNK_94] (rows=28 width=534) keys:_col7, _col14, _col2,top n:100 - Merge Join Operator [MERGEJOIN_188] (rows=28 width=534) + Merge Join Operator [MERGEJOIN_193] (rows=28 width=534) Conds:RS_44._col1, _col3=RS_45._col10, _col12(Inner),Output:["_col2","_col3","_col7","_col8","_col14","_col15"] <-Reducer 10 [SIMPLE_EDGE] llap SHUFFLE [RS_45] PartitionCols:_col10, _col12 Select Operator [SEL_40] (rows=2 width=447) Output:["_col2","_col3","_col9","_col10","_col12"] - Merge Join Operator [MERGEJOIN_187] (rows=2 width=447) + Merge Join Operator [MERGEJOIN_192] (rows=2 width=447) Conds:RS_37._col2, _col4=RS_38._col1, _col3(Inner),Output:["_col0","_col1","_col9","_col10","_col12"] <-Reducer 11 [SIMPLE_EDGE] llap SHUFFLE [RS_38] PartitionCols:_col1, _col3 - Merge Join Operator [MERGEJOIN_186] (rows=5 width=356) - Conds:RS_212._col0=RS_200._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_191] (rows=5 width=356) + Conds:RS_217._col0=RS_205._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 6 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_200] + SHUFFLE [RS_205] PartitionCols:_col0 - Select Operator [SEL_197] (rows=5 width=87) + Select Operator [SEL_202] (rows=5 width=87) Output:["_col0"] - Filter Operator [FIL_194] (rows=5 width=178) + Filter Operator [FIL_199] (rows=5 width=178) predicate:((value) IN ('2000Q1', '2000Q2', '2000Q3') and key is not null) TableScan [TS_3] (rows=500 width=178) default@src,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] <-Map 15 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_212] + SHUFFLE [RS_217] PartitionCols:_col0 - Select Operator [SEL_211] (rows=7 width=443) + Select Operator [SEL_216] (rows=7 width=443) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_210] (rows=7 width=534) + Filter Operator [FIL_215] (rows=7 width=534) predicate:((v1 = 'srv1') and k2 is not null and k3 is not null and v2 is not null and v3 is not null and k1 is not null) TableScan [TS_18] (rows=85 width=534) default@sr,sr,Tbl:COMPLETE,Col:COMPLETE,Output:["k1","v1","k2","v2","k3","v3"] <-Reducer 9 [SIMPLE_EDGE] llap SHUFFLE [RS_37] PartitionCols:_col2, _col4 - Merge Join Operator [MERGEJOIN_185] (rows=2 width=352) - Conds:RS_34._col1=RS_209._col0(Inner),Output:["_col0","_col1","_col2","_col4"] + Merge Join Operator [MERGEJOIN_190] (rows=2 width=352) + Conds:RS_34._col1=RS_214._col0(Inner),Output:["_col0","_col1","_col2","_col4"] <-Map 14 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_209] + SHUFFLE [RS_214] PartitionCols:_col0 - Select Operator [SEL_208] (rows=2 width=89) + Select Operator [SEL_213] (rows=2 width=89) Output:["_col0"] - Filter Operator [FIL_207] (rows=2 width=175) + Filter Operator [FIL_212] (rows=2 width=175) predicate:((key = 'src1key') and value is not null) TableScan [TS_15] (rows=25 width=175) default@src1,src1,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] <-Reducer 8 [SIMPLE_EDGE] llap SHUFFLE [RS_34] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_184] (rows=2 width=352) - Conds:RS_31._col3=RS_206._col0(Inner),Output:["_col0","_col1","_col2","_col4"] + Merge Join Operator [MERGEJOIN_189] (rows=2 width=352) + Conds:RS_31._col3=RS_211._col0(Inner),Output:["_col0","_col1","_col2","_col4"] <-Map 13 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_206] + SHUFFLE [RS_211] PartitionCols:_col0 - Select Operator [SEL_205] (rows=6 width=91) + Select Operator [SEL_210] (rows=6 width=91) Output:["_col0"] - Filter Operator [FIL_204] (rows=6 width=178) + Filter Operator [FIL_209] (rows=6 width=178) predicate:((key = 'srcpartkey') and value is not null) TableScan [TS_12] (rows=2000 width=178) default@srcpart,srcpart,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] <-Reducer 7 [SIMPLE_EDGE] llap SHUFFLE [RS_31] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_183] (rows=2 width=443) - Conds:RS_203._col0=RS_199._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_188] (rows=2 width=443) + Conds:RS_208._col0=RS_204._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4"] <-Map 6 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_199] + SHUFFLE [RS_204] PartitionCols:_col0 - Select Operator [SEL_196] (rows=2 width=87) + Select Operator [SEL_201] (rows=2 width=87) Output:["_col0"] - Filter Operator [FIL_193] (rows=2 width=178) + Filter Operator [FIL_198] (rows=2 width=178) predicate:((value = 'd1value') and key is not null) Please refer to the previous TableScan [TS_3] <-Map 12 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_203] + SHUFFLE [RS_208] PartitionCols:_col0 - Select Operator [SEL_202] (rows=7 width=443) + Select Operator [SEL_207] (rows=7 width=443) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_201] (rows=7 width=534) + Filter Operator [FIL_206] (rows=7 width=534) predicate:((v3 = 'ssv3') and k2 is not null and k3 is not null and k1 is not null and v1 is not null and v2 is not null) TableScan [TS_6] (rows=85 width=534) default@ss_n1,ss_n1,Tbl:COMPLETE,Col:COMPLETE,Output:["k1","v1","k2","v2","k3","v3"] <-Reducer 2 [SIMPLE_EDGE] llap SHUFFLE [RS_44] PartitionCols:_col1, _col3 - Merge Join Operator [MERGEJOIN_182] (rows=70 width=269) - Conds:RS_191._col0=RS_198._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_187] (rows=70 width=269) + Conds:RS_196._col0=RS_203._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 6 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_198] + SHUFFLE [RS_203] PartitionCols:_col0 - Select Operator [SEL_195] (rows=5 width=87) + Select Operator [SEL_200] (rows=5 width=87) Output:["_col0"] - Filter Operator [FIL_192] (rows=5 width=178) + Filter Operator [FIL_197] (rows=5 width=178) predicate:((value) IN ('2000Q1', '2000Q2', '2000Q3') and key is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_191] + SHUFFLE [RS_196] PartitionCols:_col0 - Select Operator [SEL_190] (rows=170 width=356) + Select Operator [SEL_195] (rows=170 width=356) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_189] (rows=170 width=356) + Filter Operator [FIL_194] (rows=170 width=356) predicate:(v2 is not null and v3 is not null and k1 is not null) TableScan [TS_0] (rows=170 width=356) default@cs,cs,Tbl:COMPLETE,Col:COMPLETE,Output:["k1","v2","k3","v3"] @@ -1069,104 +1069,104 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized, llap - File Output Operator [FS_234] - Limit [LIM_233] (rows=100 width=10) + File Output Operator [FS_239] + Limit [LIM_238] (rows=100 width=10) Number of rows:100 - Select Operator [SEL_232] (rows=805 width=10) + Select Operator [SEL_237] (rows=805 width=10) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 4 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_231] - Group By Operator [GBY_230] (rows=805 width=10) + SHUFFLE [RS_236] + Group By Operator [GBY_235] (rows=805 width=10) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)","count(VALUE._col1)","count(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Map 3 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_229] + SHUFFLE [RS_234] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_228] (rows=1610 width=10) + Group By Operator [GBY_233] (rows=1610 width=10) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(_col9)","count(_col16)","count(_col3)"],keys:_col8, _col15, _col2 - Top N Key Operator [TNK_227] (rows=1610 width=10) + Top N Key Operator [TNK_232] (rows=1610 width=10) keys:_col8, _col15, _col2,top n:100 - Map Join Operator [MAPJOIN_226] (rows=1610 width=10) - Conds:RS_202._col1, _col3=SEL_225._col11, _col13(Inner),Output:["_col2","_col3","_col8","_col9","_col15","_col16"] + Map Join Operator [MAPJOIN_231] (rows=1610 width=10) + Conds:RS_207._col1, _col3=SEL_230._col11, _col13(Inner),Output:["_col2","_col3","_col8","_col9","_col15","_col16"] <-Map 2 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_202] + BROADCAST [RS_207] PartitionCols:_col1, _col3 - Map Join Operator [MAPJOIN_201] (rows=550 width=10) - Conds:RS_198._col0=SEL_200._col0(Inner),Output:["_col1","_col2","_col3"] + Map Join Operator [MAPJOIN_206] (rows=550 width=10) + Conds:RS_203._col0=SEL_205._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 1 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_198] + BROADCAST [RS_203] PartitionCols:_col0 - Select Operator [SEL_197] (rows=170 width=34) + Select Operator [SEL_202] (rows=170 width=34) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_196] (rows=170 width=34) + Filter Operator [FIL_201] (rows=170 width=34) predicate:(v2 is not null and v3 is not null and k1 is not null) TableScan [TS_0] (rows=170 width=34) default@cs,cs,Tbl:COMPLETE,Col:NONE,Output:["k1","v2","k3","v3"] - <-Select Operator [SEL_200] (rows=500 width=10) + <-Select Operator [SEL_205] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_199] (rows=500 width=10) + Filter Operator [FIL_204] (rows=500 width=10) predicate:((value) IN ('2000Q1', '2000Q2', '2000Q3') and key is not null) TableScan [TS_3] (rows=500 width=10) default@src,d3,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Select Operator [SEL_225] (rows=1464 width=10) + <-Select Operator [SEL_230] (rows=1464 width=10) Output:["_col3","_col4","_col10","_col11","_col13"] - Map Join Operator [MAPJOIN_224] (rows=1464 width=10) - Conds:MAPJOIN_223._col3, _col5=RS_218._col2, _col4(Inner),Output:["_col1","_col2","_col10","_col11","_col13"] + Map Join Operator [MAPJOIN_229] (rows=1464 width=10) + Conds:MAPJOIN_228._col3, _col5=RS_223._col2, _col4(Inner),Output:["_col1","_col2","_col10","_col11","_col13"] <-Map 9 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_218] + BROADCAST [RS_223] PartitionCols:_col2, _col4 - Map Join Operator [MAPJOIN_217] (rows=550 width=10) - Conds:SEL_216._col0=RS_214._col0(Inner),Output:["_col2","_col3","_col4","_col5"] + Map Join Operator [MAPJOIN_222] (rows=550 width=10) + Conds:SEL_221._col0=RS_219._col0(Inner),Output:["_col2","_col3","_col4","_col5"] <-Map 10 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_214] + BROADCAST [RS_219] PartitionCols:_col0 - Select Operator [SEL_213] (rows=42 width=34) + Select Operator [SEL_218] (rows=42 width=34) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_212] (rows=42 width=34) + Filter Operator [FIL_217] (rows=42 width=34) predicate:((v1 = 'srv1') and k2 is not null and k3 is not null and v2 is not null and v3 is not null and k1 is not null) TableScan [TS_21] (rows=85 width=34) default@sr,sr,Tbl:COMPLETE,Col:NONE,Output:["k1","v1","k2","v2","k3","v3"] - <-Select Operator [SEL_216] (rows=500 width=10) + <-Select Operator [SEL_221] (rows=500 width=10) Output:["_col0"] - Filter Operator [FIL_215] (rows=500 width=10) + Filter Operator [FIL_220] (rows=500 width=10) predicate:((value) IN ('2000Q1', '2000Q2', '2000Q3') and key is not null) TableScan [TS_18] (rows=500 width=10) default@src,d2,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Map Join Operator [MAPJOIN_223] (rows=1331 width=10) - Conds:MAPJOIN_222._col2=RS_211._col0(Inner),Output:["_col1","_col2","_col3","_col5"] + <-Map Join Operator [MAPJOIN_228] (rows=1331 width=10) + Conds:MAPJOIN_227._col2=RS_216._col0(Inner),Output:["_col1","_col2","_col3","_col5"] <-Map 8 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_211] + BROADCAST [RS_216] PartitionCols:_col0 - Select Operator [SEL_210] (rows=12 width=7) + Select Operator [SEL_215] (rows=12 width=7) Output:["_col0"] - Filter Operator [FIL_209] (rows=12 width=7) + Filter Operator [FIL_214] (rows=12 width=7) predicate:((key = 'src1key') and value is not null) TableScan [TS_15] (rows=25 width=7) default@src1,src1,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Map Join Operator [MAPJOIN_222] (rows=1210 width=10) - Conds:MAPJOIN_221._col1=RS_208._col0(Inner),Output:["_col1","_col2","_col3","_col5"] + <-Map Join Operator [MAPJOIN_227] (rows=1210 width=10) + Conds:MAPJOIN_226._col1=RS_213._col0(Inner),Output:["_col1","_col2","_col3","_col5"] <-Map 7 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_208] + BROADCAST [RS_213] PartitionCols:_col0 - Select Operator [SEL_207] (rows=250 width=10) + Select Operator [SEL_212] (rows=250 width=10) Output:["_col0"] - Filter Operator [FIL_206] (rows=250 width=10) + Filter Operator [FIL_211] (rows=250 width=10) predicate:((value = 'd1value') and key is not null) TableScan [TS_12] (rows=500 width=10) default@src,d1,Tbl:COMPLETE,Col:NONE,Output:["key","value"] - <-Map Join Operator [MAPJOIN_221] (rows=1100 width=10) - Conds:SEL_220._col0=RS_205._col3(Inner),Output:["_col1","_col2","_col3","_col5"] + <-Map Join Operator [MAPJOIN_226] (rows=1100 width=10) + Conds:SEL_225._col0=RS_210._col3(Inner),Output:["_col1","_col2","_col3","_col5"] <-Map 6 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_205] + BROADCAST [RS_210] PartitionCols:_col3 - Select Operator [SEL_204] (rows=42 width=34) + Select Operator [SEL_209] (rows=42 width=34) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_203] (rows=42 width=34) + Filter Operator [FIL_208] (rows=42 width=34) predicate:((v3 = 'ssv3') and k2 is not null and k3 is not null and k1 is not null and v1 is not null and v2 is not null) TableScan [TS_9] (rows=85 width=34) default@ss_n1,ss_n1,Tbl:COMPLETE,Col:NONE,Output:["k1","v1","k2","v2","k3","v3"] - <-Select Operator [SEL_220] (rows=1000 width=10) + <-Select Operator [SEL_225] (rows=1000 width=10) Output:["_col0"] - Filter Operator [FIL_219] (rows=1000 width=10) + Filter Operator [FIL_224] (rows=1000 width=10) predicate:((key = 'srcpartkey') and value is not null) TableScan [TS_6] (rows=2000 width=10) default@srcpart,srcpart,Tbl:COMPLETE,Col:NONE,Output:["key","value"] diff --git ql/src/test/results/clientpositive/llap/external_jdbc_table_perf.q.out ql/src/test/results/clientpositive/llap/external_jdbc_table_perf.q.out index 545cce75a9..5bedb34804 100644 --- ql/src/test/results/clientpositive/llap/external_jdbc_table_perf.q.out +++ ql/src/test/results/clientpositive/llap/external_jdbc_table_perf.q.out @@ -1916,16 +1916,16 @@ GROUP BY "t0"."cs_ship_customer_sk" Filter Operator predicate: _col42 is null (type: boolean) Statistics: Num rows: 1 Data size: 499 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) - outputColumnNames: _col32, _col33, _col34, _col35, _col36 + Top N Key Operator + sort order: +++++ + keys: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) + null sort order: zzzzz Statistics: Num rows: 1 Data size: 499 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: +++++ - keys: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) - null sort order: zzzzz + top n: 100 + Select Operator + expressions: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) + outputColumnNames: _col32, _col33, _col34, _col35, _col36 Statistics: Num rows: 1 Data size: 499 Basic stats: COMPLETE Column stats: NONE - top n: 100 Group By Operator aggregations: count() keys: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) @@ -2406,16 +2406,16 @@ GROUP BY "t0"."cs_ship_customer_sk" Filter Operator predicate: _col42 is null (type: boolean) Statistics: Num rows: 1 Data size: 499 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) - outputColumnNames: _col32, _col33, _col34, _col35, _col36 + Top N Key Operator + sort order: +++++ + keys: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) + null sort order: zzzzz Statistics: Num rows: 1 Data size: 499 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: +++++ - keys: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) - null sort order: zzzzz + top n: 100 + Select Operator + expressions: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) + outputColumnNames: _col32, _col33, _col34, _col35, _col36 Statistics: Num rows: 1 Data size: 499 Basic stats: COMPLETE Column stats: NONE - top n: 100 Group By Operator aggregations: count() keys: _col32 (type: char(1)), _col33 (type: char(1)), _col34 (type: char(20)), _col35 (type: int), _col36 (type: char(10)) @@ -3156,13 +3156,19 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 212 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col1 (type: decimal(27,2)) - null sort order: z + Top N Key Operator sort order: + + keys: _col1 (type: decimal(27,2)) + null sort order: z Statistics: Num rows: 1 Data size: 212 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: char(16)) + top n: 100 + Reduce Output Operator + key expressions: _col1 (type: decimal(27,2)) + null sort order: z + sort order: + + Statistics: Num rows: 1 Data size: 212 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: char(16)) Reducer 4 Execution mode: vectorized, llap Reduce Operator Tree: @@ -3977,17 +3983,23 @@ WHERE "d_week_seq" IS NOT NULL AND "d_date" IS NOT NULL 1 _col0 (type: char(16)) outputColumnNames: _col0, _col1, _col2, _col4, _col5, _col7, _col8 Statistics: Num rows: 1 Data size: 92 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: char(16)), _col1 (type: bigint), (((_col2 / UDFToDouble(((_col1 + _col7) + _col4))) / 3.0D) * 100.0D) (type: double), _col7 (type: bigint), (((_col8 / UDFToDouble(((_col1 + _col7) + _col4))) / 3.0D) * 100.0D) (type: double), _col4 (type: bigint), (((_col5 / UDFToDouble(((_col1 + _col7) + _col4))) / 3.0D) * 100.0D) (type: double), (CAST( ((_col1 + _col7) + _col4) AS decimal(19,0)) / 3) (type: decimal(25,6)) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Top N Key Operator + sort order: ++ + keys: _col0 (type: char(16)), _col1 (type: bigint) + null sort order: zz Statistics: Num rows: 1 Data size: 92 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: char(16)), _col1 (type: bigint) - null sort order: zz - sort order: ++ + top n: 100 + Select Operator + expressions: _col0 (type: char(16)), _col1 (type: bigint), (((_col2 / UDFToDouble(((_col1 + _col7) + _col4))) / 3.0D) * 100.0D) (type: double), _col7 (type: bigint), (((_col8 / UDFToDouble(((_col1 + _col7) + _col4))) / 3.0D) * 100.0D) (type: double), _col4 (type: bigint), (((_col5 / UDFToDouble(((_col1 + _col7) + _col4))) / 3.0D) * 100.0D) (type: double), (CAST( ((_col1 + _col7) + _col4) AS decimal(19,0)) / 3) (type: decimal(25,6)) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Statistics: Num rows: 1 Data size: 92 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col2 (type: double), _col3 (type: bigint), _col4 (type: double), _col5 (type: bigint), _col6 (type: double), _col7 (type: decimal(25,6)) + Reduce Output Operator + key expressions: _col0 (type: char(16)), _col1 (type: bigint) + null sort order: zz + sort order: ++ + Statistics: Num rows: 1 Data size: 92 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col2 (type: double), _col3 (type: bigint), _col4 (type: double), _col5 (type: bigint), _col6 (type: double), _col7 (type: decimal(25,6)) Reducer 7 Execution mode: vectorized, llap Reduce Operator Tree: @@ -4297,13 +4309,19 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 116 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col1 (type: decimal(27,2)) - null sort order: z + Top N Key Operator sort order: + + keys: _col1 (type: decimal(27,2)) + null sort order: z Statistics: Num rows: 1 Data size: 116 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: int) + top n: 100 + Reduce Output Operator + key expressions: _col1 (type: decimal(27,2)) + null sort order: z + sort order: + + Statistics: Num rows: 1 Data size: 116 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: int) Reducer 4 Execution mode: vectorized, llap Reduce Operator Tree: @@ -5650,16 +5668,22 @@ GROUP BY "t2"."r_reason_desc" hive.sql.query.fieldTypes char(100),bigint,bigint,decimal(11,6),bigint,decimal(11,6),bigint hive.sql.query.split false Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: substr(r_reason_desc, 1, 20) (type: string), (UDFToDouble($f1) / $f2) (type: double), ($f3 / $f4) (type: decimal(31,26)), ($f5 / $f6) (type: decimal(31,26)) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: ++++ + keys: substr(r_reason_desc, 1, 20) (type: string), (UDFToDouble($f1) / $f2) (type: double), ($f3 / $f4) (type: decimal(31,26)), ($f5 / $f6) (type: decimal(31,26)) + null sort order: zzzz Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: double), _col2 (type: decimal(31,26)), _col3 (type: decimal(31,26)) - null sort order: zzzz - sort order: ++++ + top n: 100 + Select Operator + expressions: substr(r_reason_desc, 1, 20) (type: string), (UDFToDouble($f1) / $f2) (type: double), ($f3 / $f4) (type: decimal(31,26)), ($f5 / $f6) (type: decimal(31,26)) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: double), _col2 (type: decimal(31,26)), _col3 (type: decimal(31,26)) + null sort order: zzzz + sort order: ++++ + Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/filter_union.q.out ql/src/test/results/clientpositive/llap/filter_union.q.out index 0df77762a0..b7d572a42b 100644 --- ql/src/test/results/clientpositive/llap/filter_union.q.out +++ ql/src/test/results/clientpositive/llap/filter_union.q.out @@ -526,16 +526,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: a Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: a + top n: 0 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 0 Group By Operator aggregations: count(key) keys: key (type: string) diff --git ql/src/test/results/clientpositive/llap/groupby_groupingset_bug.q.out ql/src/test/results/clientpositive/llap/groupby_groupingset_bug.q.out index 63d56172b7..694ef329ac 100644 --- ql/src/test/results/clientpositive/llap/groupby_groupingset_bug.q.out +++ ql/src/test/results/clientpositive/llap/groupby_groupingset_bug.q.out @@ -226,94 +226,96 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized, llap - File Output Operator [FS_143] - Limit [LIM_142] (rows=2 width=8) + File Output Operator [FS_145] + Limit [LIM_144] (rows=2 width=8) Number of rows:100 - Select Operator [SEL_141] (rows=2 width=8) + Select Operator [SEL_143] (rows=2 width=8) Output:["_col0"] <-Reducer 5 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_140] - Select Operator [SEL_139] (rows=2 width=8) + SHUFFLE [RS_142] + Select Operator [SEL_141] (rows=2 width=8) Output:["_col0"] - Group By Operator [GBY_138] (rows=2 width=12) - Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 - <-Map 4 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_137] - PartitionCols:_col0 - Group By Operator [GBY_136] (rows=2 width=12) - Output:["_col0","_col1"],aggregations:["count()"],keys:_col8 - Map Join Operator [MAPJOIN_135] (rows=5185194 width=4) - Conds:MAPJOIN_134._col6=RS_128._col0(Inner),Output:["_col8"] - <-Map 7 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_128] - PartitionCols:_col0 - Map Join Operator [MAPJOIN_127] (rows=28 width=8) - Conds:SEL_126._col1=RS_124._col0(Inner),Output:["_col0","_col1"] - <-Reducer 9 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_124] + Top N Key Operator [TNK_140] (rows=2 width=12) + keys:_col1,top n:100 + Group By Operator [GBY_139] (rows=2 width=12) + Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 + <-Map 4 [SIMPLE_EDGE] vectorized, llap + SHUFFLE [RS_138] + PartitionCols:_col0 + Group By Operator [GBY_137] (rows=2 width=12) + Output:["_col0","_col1"],aggregations:["count()"],keys:_col8 + Map Join Operator [MAPJOIN_136] (rows=5185194 width=4) + Conds:MAPJOIN_135._col6=RS_129._col0(Inner),Output:["_col8"] + <-Map 7 [BROADCAST_EDGE] vectorized, llap + BROADCAST [RS_129] + PartitionCols:_col0 + Map Join Operator [MAPJOIN_128] (rows=28 width=8) + Conds:SEL_127._col1=RS_125._col0(Inner),Output:["_col0","_col1"] + <-Reducer 9 [BROADCAST_EDGE] vectorized, llap + BROADCAST [RS_125] + PartitionCols:_col0 + Group By Operator [GBY_124] (rows=2 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 8 [SIMPLE_EDGE] vectorized, llap + SHUFFLE [RS_123] + PartitionCols:_col0 + Group By Operator [GBY_122] (rows=2 width=4) + Output:["_col0"],keys:d_month_seq + Select Operator [SEL_121] (rows=4 width=12) + Output:["d_month_seq"] + Filter Operator [FIL_120] (rows=4 width=12) + predicate:((d_year = 2000) and ((d_year * d_moy) > 200000) and (d_moy = 2) and d_month_seq is not null) + TableScan [TS_17] (rows=28 width=12) + default@x1_date_dim,x1_date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] + <-Select Operator [SEL_127] (rows=28 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_126] (rows=28 width=8) + predicate:(d_date_sk is not null and d_month_seq is not null) + TableScan [TS_14] (rows=28 width=8) + default@x1_date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + Dynamic Partitioning Event Operator [EVENT_132] (rows=1 width=4) + Group By Operator [GBY_131] (rows=1 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_130] (rows=28 width=8) + Output:["_col0"] + Please refer to the previous Map Join Operator [MAPJOIN_128] + <-Map Join Operator [MAPJOIN_135] (rows=370371 width=4) + Conds:RS_31._col0=SEL_134._col0(Inner),Output:["_col6"] + <-Map 1 [BROADCAST_EDGE] llap + BROADCAST [RS_31] PartitionCols:_col0 - Group By Operator [GBY_123] (rows=2 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 8 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_122] - PartitionCols:_col0 - Group By Operator [GBY_121] (rows=2 width=4) - Output:["_col0"],keys:d_month_seq - Select Operator [SEL_120] (rows=4 width=12) - Output:["d_month_seq"] - Filter Operator [FIL_119] (rows=4 width=12) - predicate:((d_year = 2000) and ((d_year * d_moy) > 200000) and (d_moy = 2) and d_month_seq is not null) - TableScan [TS_17] (rows=28 width=12) - default@x1_date_dim,x1_date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] - <-Select Operator [SEL_126] (rows=28 width=8) + Map Join Operator [MAPJOIN_103] (rows=6 width=228) + Conds:SEL_2._col1=RS_117._col1(Inner),Output:["_col0","_col2","_col3"],residual filter predicates:{(_col2 > _col3)} + <-Reducer 3 [BROADCAST_EDGE] vectorized, llap + BROADCAST [RS_117] + PartitionCols:_col1 + Select Operator [SEL_116] (rows=1 width=197) + Output:["_col0","_col1"] + Filter Operator [FIL_115] (rows=1 width=197) + predicate:_col1 is not null + Group By Operator [GBY_114] (rows=1 width=197) + Output:["_col0","_col1"],aggregations:["min(VALUE._col0)"],keys:KEY._col0 + <-Map 2 [SIMPLE_EDGE] vectorized, llap + SHUFFLE [RS_113] + PartitionCols:_col0 + Group By Operator [GBY_112] (rows=1 width=197) + Output:["_col0","_col1"],aggregations:["min(i_current_price)"],keys:i_category + Filter Operator [FIL_111] (rows=18 width=197) + predicate:i_category is not null + TableScan [TS_3] (rows=18 width=197) + default@x1_item,j,Tbl:COMPLETE,Col:COMPLETE,Output:["i_category","i_current_price"] + <-Select Operator [SEL_2] (rows=18 width=201) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_58] (rows=18 width=201) + predicate:(i_item_sk is not null and i_category is not null and i_current_price is not null) + TableScan [TS_0] (rows=18 width=201) + default@x1_item,i,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category","i_current_price"] + <-Select Operator [SEL_134] (rows=123457 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_125] (rows=28 width=8) - predicate:(d_date_sk is not null and d_month_seq is not null) - TableScan [TS_14] (rows=28 width=8) - default@x1_date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - Dynamic Partitioning Event Operator [EVENT_131] (rows=1 width=4) - Group By Operator [GBY_130] (rows=1 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_129] (rows=28 width=8) - Output:["_col0"] - Please refer to the previous Map Join Operator [MAPJOIN_127] - <-Map Join Operator [MAPJOIN_134] (rows=370371 width=4) - Conds:RS_31._col0=SEL_133._col0(Inner),Output:["_col6"] - <-Map 1 [BROADCAST_EDGE] llap - BROADCAST [RS_31] - PartitionCols:_col0 - Map Join Operator [MAPJOIN_102] (rows=6 width=228) - Conds:SEL_2._col1=RS_116._col1(Inner),Output:["_col0","_col2","_col3"],residual filter predicates:{(_col2 > _col3)} - <-Reducer 3 [BROADCAST_EDGE] vectorized, llap - BROADCAST [RS_116] - PartitionCols:_col1 - Select Operator [SEL_115] (rows=1 width=197) - Output:["_col0","_col1"] - Filter Operator [FIL_114] (rows=1 width=197) - predicate:_col1 is not null - Group By Operator [GBY_113] (rows=1 width=197) - Output:["_col0","_col1"],aggregations:["min(VALUE._col0)"],keys:KEY._col0 - <-Map 2 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_112] - PartitionCols:_col0 - Group By Operator [GBY_111] (rows=1 width=197) - Output:["_col0","_col1"],aggregations:["min(i_current_price)"],keys:i_category - Filter Operator [FIL_110] (rows=18 width=197) - predicate:i_category is not null - TableScan [TS_3] (rows=18 width=197) - default@x1_item,j,Tbl:COMPLETE,Col:COMPLETE,Output:["i_category","i_current_price"] - <-Select Operator [SEL_2] (rows=18 width=201) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_58] (rows=18 width=201) - predicate:(i_item_sk is not null and i_category is not null and i_current_price is not null) - TableScan [TS_0] (rows=18 width=201) - default@x1_item,i,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category","i_current_price"] - <-Select Operator [SEL_133] (rows=123457 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_132] (rows=123457 width=8) - predicate:ss_item_sk is not null - TableScan [TS_11] (rows=123457 width=8) - default@x1_store_sales,s,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk"] + Filter Operator [FIL_133] (rows=123457 width=8) + predicate:ss_item_sk is not null + TableScan [TS_11] (rows=123457 width=8) + default@x1_store_sales,s,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk"] PREHOOK: query: select count(*) cnt from diff --git ql/src/test/results/clientpositive/llap/insert1_overwrite_partitions.q.out ql/src/test/results/clientpositive/llap/insert1_overwrite_partitions.q.out index d51654bc5b..1490fd0032 100644 --- ql/src/test/results/clientpositive/llap/insert1_overwrite_partitions.q.out +++ ql/src/test/results/clientpositive/llap/insert1_overwrite_partitions.q.out @@ -65,16 +65,22 @@ STAGE PLANS: alias: sourcetable filterExpr: ((ds = '2011-11-11') and (hr = '11')) (type: boolean) Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - Select Operator - expressions: one (type: string), two (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: -- + keys: one (type: string), two (type: string) + null sort order: zz Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: -- + top n: 5 + Select Operator + expressions: one (type: string), two (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: -- + Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -264,16 +270,22 @@ STAGE PLANS: alias: sourcetable filterExpr: ((ds = '2011-11-11') and (hr = '11')) (type: boolean) Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - Select Operator - expressions: one (type: string), two (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: -- + keys: one (type: string), two (type: string) + null sort order: zz Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: -- + top n: 5 + Select Operator + expressions: one (type: string), two (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: -- + Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -432,16 +444,22 @@ STAGE PLANS: alias: sourcetable filterExpr: ((ds = '2011-11-11') and (hr = '11')) (type: boolean) Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - Select Operator - expressions: one (type: string), two (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: -- + keys: one (type: string), two (type: string) + null sort order: zz Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string), _col1 (type: string) - null sort order: zz - sort order: -- + top n: 5 + Select Operator + expressions: one (type: string), two (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: zz + sort order: -- + Statistics: Num rows: 99 Data size: 31648 Basic stats: PARTIAL Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/insert_into1.q.out ql/src/test/results/clientpositive/llap/insert_into1.q.out index dd9140d3b6..960bee71a0 100644 --- ql/src/test/results/clientpositive/llap/insert_into1.q.out +++ ql/src/test/results/clientpositive/llap/insert_into1.q.out @@ -38,17 +38,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -205,17 +211,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -372,17 +384,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/insert_into2.q.out ql/src/test/results/clientpositive/llap/insert_into2.q.out index 161318b720..2f80d93072 100644 --- ql/src/test/results/clientpositive/llap/insert_into2.q.out +++ ql/src/test/results/clientpositive/llap/insert_into2.q.out @@ -42,17 +42,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -262,17 +268,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -447,17 +459,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 50 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/lateral_view.q.out ql/src/test/results/clientpositive/llap/lateral_view.q.out index b742230a71..5cd9fb61a1 100644 --- ql/src/test/results/clientpositive/llap/lateral_view.q.out +++ ql/src/test/results/clientpositive/llap/lateral_view.q.out @@ -50,17 +50,23 @@ STAGE PLANS: Lateral View Join Operator outputColumnNames: _col0, _col1, _col5 Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1, _col2 + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col5 (type: int) + null sort order: zz Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col2 (type: int) - null sort order: zz - sort order: ++ + top n: 1 + Select Operator + expressions: _col0 (type: string), _col1 (type: string), _col5 (type: int) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string), _col2 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Select Operator expressions: array(1,2,3) (type: array) outputColumnNames: _col0 @@ -71,17 +77,23 @@ STAGE PLANS: Lateral View Join Operator outputColumnNames: _col0, _col1, _col5 Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: string), _col1 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1, _col2 + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col5 (type: int) + null sort order: zz Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col2 (type: int) - null sort order: zz - sort order: ++ + top n: 1 + Select Operator + expressions: _col0 (type: string), _col1 (type: string), _col5 (type: int) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string), _col2 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 1000 Data size: 289000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -94,13 +106,19 @@ STAGE PLANS: Limit Number of rows: 1 Statistics: Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string), _col2 (type: int) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col0 (type: string), _col2 (type: int) + null sort order: zz Statistics: Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + top n: 1 + Reduce Output Operator + key expressions: _col0 (type: string), _col2 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 1 Data size: 178 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/limit_join_transpose.q.out ql/src/test/results/clientpositive/llap/limit_join_transpose.q.out index 6258f4fe1e..fd04fcfa00 100644 --- ql/src/test/results/clientpositive/llap/limit_join_transpose.q.out +++ ql/src/test/results/clientpositive/llap/limit_join_transpose.q.out @@ -762,17 +762,23 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE value expressions: _col1 (type: string) - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 1 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Map 7 @@ -807,20 +813,26 @@ STAGE PLANS: 1 _col0 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col2 (type: string) - null sort order: z + Top N Key Operator sort order: + + keys: _col2 (type: string) + null sort order: z Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) + top n: 1 + Reduce Output Operator + key expressions: _col2 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) Reducer 3 Execution mode: llap Reduce Operator Tree: Select Operator expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 534 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 1 Statistics: Num rows: 1 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE @@ -859,17 +871,23 @@ STAGE PLANS: 1 _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: string), _col2 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: _col1 (type: string) + null sort order: z Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 1 + Select Operator + expressions: _col1 (type: string), _col2 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Reducer 6 Execution mode: llap Reduce Operator Tree: @@ -1743,17 +1761,23 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE value expressions: _col1 (type: string) - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 2 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Map 7 @@ -1788,20 +1812,26 @@ STAGE PLANS: 1 _col0 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col2 (type: string) - null sort order: z + Top N Key Operator sort order: + + keys: _col2 (type: string) + null sort order: z Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) + top n: 2 + Reduce Output Operator + key expressions: _col2 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: string) Reducer 3 Execution mode: llap Reduce Operator Tree: Select Operator expressions: VALUE._col0 (type: string), VALUE._col1 (type: string), KEY.reducesinkkey0 (type: string), VALUE._col2 (type: string) outputColumnNames: _col0, _col1, _col2, _col3 - Statistics: Num rows: 2 Data size: 712 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2 Data size: 534 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 1 Offset of rows: 1 @@ -1842,17 +1872,23 @@ STAGE PLANS: 1 _col1 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: string), _col2 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: _col1 (type: string) + null sort order: z Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 2 + Select Operator + expressions: _col1 (type: string), _col2 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 2 Data size: 356 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Reducer 6 Execution mode: llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/limit_pushdown.q.out ql/src/test/results/clientpositive/llap/limit_pushdown.q.out index 3fdd77d802..d882856ad3 100644 --- ql/src/test/results/clientpositive/llap/limit_pushdown.q.out +++ ql/src/test/results/clientpositive/llap/limit_pushdown.q.out @@ -25,17 +25,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 20 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -117,17 +123,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: - + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: - + top n: 20 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -209,16 +221,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 20 + Select Operator + expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator aggregations: sum(_col1) keys: _col0 (type: string) @@ -317,16 +329,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 20 + Select Operator + expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator aggregations: sum(_col1), count(_col1) keys: _col0 (type: string) @@ -429,16 +441,16 @@ STAGE PLANS: TableScan alias: alltypesorc Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cdouble (type: double) - outputColumnNames: cdouble + Top N Key Operator + sort order: + + keys: cdouble (type: double) + null sort order: z Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: cdouble (type: double) - null sort order: z + top n: 20 + Select Operator + expressions: cdouble (type: double) + outputColumnNames: cdouble Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator keys: cdouble (type: double) minReductionHashAggr: 0.55013025 @@ -908,13 +920,19 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: double) - null sort order: z + Top N Key Operator sort order: + + keys: _col1 (type: double) + null sort order: z Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col0 (type: string) + top n: 20 + Reduce Output Operator + key expressions: _col1 (type: double) + null sort order: z + sort order: + + Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col0 (type: string) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: @@ -1005,16 +1023,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: z + top n: 2 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 2 Group By Operator aggregations: count() keys: key (type: string) @@ -1030,12 +1048,16 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE TopN Hash Memory Usage: 0.3 value expressions: _col1 (type: bigint) - Top N Key Operator - sort order: + - keys: key (type: string) - null sort order: a + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: a + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + top n: 3 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 3 Group By Operator aggregations: count() keys: key (type: string) @@ -1168,18 +1190,24 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: key, value + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: value (type: string) - null sort order: z - sort order: + - Map-reduce partition columns: value (type: string) + top n: 20 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: key, value Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: key (type: string) + Reduce Output Operator + key expressions: value (type: string) + null sort order: z + sort order: + + Map-reduce partition columns: value (type: string) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: key (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -1263,17 +1291,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -1458,16 +1492,22 @@ STAGE PLANS: mode: complete outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: double) - outputColumnNames: _col0 - Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: _col1 (type: double) + null sort order: z + Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: _col1 (type: double) + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 + Reduce Output Operator + key expressions: _col0 (type: double) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/limit_pushdown3.q.out ql/src/test/results/clientpositive/llap/limit_pushdown3.q.out index efa8c38d7c..1a4a3b5da1 100644 --- ql/src/test/results/clientpositive/llap/limit_pushdown3.q.out +++ ql/src/test/results/clientpositive/llap/limit_pushdown3.q.out @@ -25,17 +25,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 20 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -117,17 +123,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: - + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: - + top n: 20 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -210,16 +222,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 20 + Select Operator + expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator aggregations: sum(_col1) keys: _col0 (type: string) @@ -333,16 +345,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 20 + Select Operator + expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator aggregations: sum(_col1), count(_col1) keys: _col0 (type: string) @@ -460,16 +472,16 @@ STAGE PLANS: TableScan alias: alltypesorc Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cdouble (type: double) - outputColumnNames: cdouble + Top N Key Operator + sort order: + + keys: cdouble (type: double) + null sort order: z Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: cdouble (type: double) - null sort order: z + top n: 20 + Select Operator + expressions: cdouble (type: double) + outputColumnNames: cdouble Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator keys: cdouble (type: double) minReductionHashAggr: 0.55013025 @@ -600,37 +612,43 @@ STAGE PLANS: Reducer 2 Execution mode: vectorized, llap Reduce Operator Tree: - Group By Operator - keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) - mode: mergepartial - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: KEY._col0 (type: tinyint) + null sort order: z Statistics: Num rows: 6144 Data size: 55052 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 Group By Operator - aggregations: count(_col1) - keys: _col0 (type: tinyint) - mode: complete + keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) + mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint) - null sort order: z - sort order: + - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: bigint) + Statistics: Num rows: 6144 Data size: 36364 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(_col1) + keys: _col0 (type: tinyint) + mode: complete + outputColumnNames: _col0, _col1 + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint) + null sort order: z + sort order: + + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: bigint) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: tinyint), VALUE._col0 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -719,37 +737,43 @@ STAGE PLANS: Reducer 2 Execution mode: vectorized, llap Reduce Operator Tree: - Group By Operator - keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) - mode: mergepartial - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: KEY._col0 (type: tinyint) + null sort order: z Statistics: Num rows: 6144 Data size: 55052 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 Group By Operator - aggregations: count(_col1) - keys: _col0 (type: tinyint) - mode: complete + keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) + mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint) - null sort order: z - sort order: + - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: bigint) + Statistics: Num rows: 6144 Data size: 36364 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(_col1) + keys: _col0 (type: tinyint) + mode: complete + outputColumnNames: _col0, _col1 + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint) + null sort order: z + sort order: + + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: bigint) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: tinyint), VALUE._col0 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 204 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -838,41 +862,47 @@ STAGE PLANS: Reducer 2 Execution mode: vectorized, llap Reduce Operator Tree: - Group By Operator - keys: KEY._col0 (type: tinyint), KEY._col1 (type: string), KEY._col2 (type: string), KEY._col3 (type: bigint) - mode: mergepartial - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: + + keys: KEY._col0 (type: tinyint) + null sort order: z Statistics: Num rows: 24576 Data size: 3756114 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: CASE WHEN (((_col3 = 1L) and _col1 is not null)) THEN (1) ELSE (null) END (type: int), CASE WHEN (((_col3 = 2L) and _col2 is not null)) THEN (1) ELSE (null) END (type: int), _col0 (type: tinyint) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 24576 Data size: 3756114 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator - aggregations: count(_col0), count(_col1) - keys: _col2 (type: tinyint) - mode: complete + top n: 20 + Group By Operator + keys: KEY._col0 (type: tinyint), KEY._col1 (type: string), KEY._col2 (type: string), KEY._col3 (type: bigint) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 24576 Data size: 2547682 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: CASE WHEN (((_col3 = 1L) and _col1 is not null)) THEN (1) ELSE (null) END (type: int), CASE WHEN (((_col3 = 2L) and _col2 is not null)) THEN (1) ELSE (null) END (type: int), _col0 (type: tinyint) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 131 Data size: 2492 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint) - null sort order: z - sort order: + - Statistics: Num rows: 131 Data size: 2492 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: bigint), _col2 (type: bigint) + Statistics: Num rows: 24576 Data size: 2547682 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(_col0), count(_col1) + keys: _col2 (type: tinyint) + mode: complete + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 131 Data size: 2360 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint) + null sort order: z + sort order: + + Statistics: Num rows: 131 Data size: 2360 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: bigint), _col2 (type: bigint) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: tinyint), VALUE._col0 (type: bigint), VALUE._col1 (type: bigint) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 131 Data size: 2492 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 131 Data size: 2360 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 - Statistics: Num rows: 20 Data size: 384 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 364 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 20 Data size: 384 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 364 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -997,13 +1027,19 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: double) - null sort order: z + Top N Key Operator sort order: + + keys: _col1 (type: double) + null sort order: z Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col0 (type: string) + top n: 20 + Reduce Output Operator + key expressions: _col1 (type: double) + null sort order: z + sort order: + + Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col0 (type: string) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: @@ -1084,18 +1120,24 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: key, value + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: value (type: string) - null sort order: z - sort order: + - Map-reduce partition columns: value (type: string) + top n: 20 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: key, value Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: key (type: string) + Reduce Output Operator + key expressions: value (type: string) + null sort order: z + sort order: + + Map-reduce partition columns: value (type: string) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: key (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -1193,17 +1235,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -1388,16 +1436,22 @@ STAGE PLANS: mode: complete outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: double) - outputColumnNames: _col0 - Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: _col1 (type: double) + null sort order: z + Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: _col1 (type: double) + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 + Reduce Output Operator + key expressions: _col0 (type: double) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/materialized_view_rewrite_8.q.out ql/src/test/results/clientpositive/llap/materialized_view_rewrite_8.q.out index 303111a7d4..844d934b2a 100644 --- ql/src/test/results/clientpositive/llap/materialized_view_rewrite_8.q.out +++ ql/src/test/results/clientpositive/llap/materialized_view_rewrite_8.q.out @@ -249,17 +249,23 @@ STAGE PLANS: TableScan alias: default.source_table_001_mv Statistics: Num rows: 1 Data size: 159 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: down_volume_sum (type: bigint), my_date (type: date), my_id2 (type: bigint), environment (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: + + keys: my_id2 (type: bigint) + null sort order: z Statistics: Num rows: 1 Data size: 159 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col2 (type: bigint) - null sort order: z - sort order: + + top n: 100 + Select Operator + expressions: down_volume_sum (type: bigint), my_date (type: date), my_id2 (type: bigint), environment (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 1 Data size: 159 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: bigint), _col1 (type: date), _col3 (type: string) + Reduce Output Operator + key expressions: _col2 (type: bigint) + null sort order: z + sort order: + + Statistics: Num rows: 1 Data size: 159 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: bigint), _col1 (type: date), _col3 (type: string) Execution mode: vectorized, llap LLAP IO: all inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/offset_limit.q.out ql/src/test/results/clientpositive/llap/offset_limit.q.out index 23f2de46e5..05342d1505 100644 --- ql/src/test/results/clientpositive/llap/offset_limit.q.out +++ ql/src/test/results/clientpositive/llap/offset_limit.q.out @@ -26,16 +26,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), substr(value, 5) (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 20 + Select Operator + expressions: key (type: string), substr(value, 5) (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 Group By Operator aggregations: sum(_col1) keys: _col0 (type: string) diff --git ql/src/test/results/clientpositive/llap/offset_limit_ppd_optimizer.q.out ql/src/test/results/clientpositive/llap/offset_limit_ppd_optimizer.q.out index 4ecb7bc46d..6eecb255f7 100644 --- ql/src/test/results/clientpositive/llap/offset_limit_ppd_optimizer.q.out +++ ql/src/test/results/clientpositive/llap/offset_limit_ppd_optimizer.q.out @@ -25,17 +25,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 30 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -118,17 +124,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: - + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: - + top n: 30 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -211,16 +223,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 30 + Select Operator + expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 30 Group By Operator aggregations: sum(_col1) keys: _col0 (type: string) @@ -320,16 +332,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 30 + Select Operator + expressions: value (type: string), (UDFToDouble(key) + 1.0D) (type: double) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 30 Group By Operator aggregations: sum(_col1), count(_col1) keys: _col0 (type: string) @@ -433,16 +445,16 @@ STAGE PLANS: TableScan alias: alltypesorc Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cdouble (type: double) - outputColumnNames: cdouble + Top N Key Operator + sort order: + + keys: cdouble (type: double) + null sort order: z Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: cdouble (type: double) - null sort order: z + top n: 30 + Select Operator + expressions: cdouble (type: double) + outputColumnNames: cdouble Statistics: Num rows: 12288 Data size: 73400 Basic stats: COMPLETE Column stats: COMPLETE - top n: 30 Group By Operator keys: cdouble (type: double) minReductionHashAggr: 0.55013025 @@ -916,12 +928,18 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: double), _col0 (type: string) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col1 (type: double), _col0 (type: string) + null sort order: zz Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 + top n: 30 + Reduce Output Operator + key expressions: _col1 (type: double), _col0 (type: string) + null sort order: zz + sort order: ++ + Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -1002,18 +1020,24 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: key, value + Top N Key Operator + sort order: + + keys: value (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: value (type: string) - null sort order: z - sort order: + - Map-reduce partition columns: value (type: string) + top n: 30 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: key, value Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 - value expressions: key (type: string) + Reduce Output Operator + key expressions: value (type: string) + null sort order: z + sort order: + + Map-reduce partition columns: value (type: string) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 + value expressions: key (type: string) Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -1098,17 +1122,23 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 407500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Reducer 2 @@ -1264,16 +1294,22 @@ STAGE PLANS: mode: complete outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: double) - outputColumnNames: _col0 - Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: _col1 (type: double) + null sort order: z + Statistics: Num rows: 500 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: _col1 (type: double) + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 + Reduce Output Operator + key expressions: _col0 (type: double) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -1415,24 +1451,40 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: key + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: key (type: string) - null sort order: z - sort order: + - Map-reduce partition columns: key (type: string) + top n: 30 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 - Reduce Output Operator - key expressions: key (type: string) - null sort order: a - sort order: + - Map-reduce partition columns: key (type: string) + Reduce Output Operator + key expressions: key (type: string) + null sort order: z + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: a + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + top n: 40 + Select Operator + expressions: key (type: string) + outputColumnNames: key Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 2.0E-5 + Reduce Output Operator + key expressions: key (type: string) + null sort order: a + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 2.0E-5 Execution mode: llap LLAP IO: no inputs Reducer 2 diff --git ql/src/test/results/clientpositive/llap/orc_predicate_pushdown.q.out ql/src/test/results/clientpositive/llap/orc_predicate_pushdown.q.out index 2fd8faa7b5..29deff9eca 100644 --- ql/src/test/results/clientpositive/llap/orc_predicate_pushdown.q.out +++ ql/src/test/results/clientpositive/llap/orc_predicate_pushdown.q.out @@ -836,17 +836,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 0Y) and (d >= 10.0D) and (d < 12.0D) and UDFToInteger(si) BETWEEN 300 AND 400 and (s like '%son') and (not (s like '%car%'))) (type: boolean) Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs Reducer 2 @@ -920,17 +926,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 0Y) and (d >= 10.0D) and (d < 12.0D) and UDFToInteger(si) BETWEEN 300 AND 400 and (s like '%son') and (not (s like '%car%'))) (type: boolean) Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs Reducer 2 @@ -1070,17 +1082,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 10Y) and (t <> 101Y) and (d >= 10) and (d < 12.0D) and (s like '%son') and (not (s like '%car%')) and (t > 0Y) and si BETWEEN 300 AND 400) (type: boolean) Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs Reducer 2 @@ -1093,13 +1111,19 @@ STAGE PLANS: Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z + Top N Key Operator sort order: - + keys: _col3 (type: string) + null sort order: z Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + top n: 3 + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -1176,17 +1200,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 10Y) and (t <> 101Y) and (d >= 10) and (d < 12.0D) and (s like '%son') and (not (s like '%car%')) and (t > 0Y) and si BETWEEN 300 AND 400) (type: boolean) Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs Reducer 2 @@ -1199,13 +1229,19 @@ STAGE PLANS: Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z + Top N Key Operator sort order: - + keys: _col3 (type: string) + null sort order: z Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + top n: 3 + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reducer 3 Execution mode: llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/orc_struct_type_vectorization.q.out ql/src/test/results/clientpositive/llap/orc_struct_type_vectorization.q.out index 0eac389eb7..c7791426c0 100644 --- ql/src/test/results/clientpositive/llap/orc_struct_type_vectorization.q.out +++ ql/src/test/results/clientpositive/llap/orc_struct_type_vectorization.q.out @@ -237,32 +237,32 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 4:int, val 500)(children: VectorUDFStructField(col 1:struct, col 0:int) -> 4:int) predicate: (st1.f1 > 500) (type: boolean) Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: st1.f1 (type: int) - outputColumnNames: _col0 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [5] - selectExpressions: VectorUDFStructField(col 1:struct, col 0:int) -> 5:int + Top N Key Operator + sort order: + + keys: st1.f1 (type: int) + null sort order: a Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: a - Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 5:int + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: VectorUDFStructField(col 1:struct, col 0:int) -> 5:int + native: true + Select Operator + expressions: st1.f1 (type: int) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [4] + selectExpressions: VectorUDFStructField(col 1:struct, col 0:int) -> 4:int + Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: sum(_col0) Group By Vectorization: - aggregators: VectorUDAFSumLong(col 5:int) -> bigint + aggregators: VectorUDAFSumLong(col 4:int) -> bigint className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 5:int + keyExpressions: col 4:int native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0] diff --git ql/src/test/results/clientpositive/llap/parquet_complex_types_vectorization.q.out ql/src/test/results/clientpositive/llap/parquet_complex_types_vectorization.q.out index 4362fb6f2e..e4788b14b0 100644 --- ql/src/test/results/clientpositive/llap/parquet_complex_types_vectorization.q.out +++ ql/src/test/results/clientpositive/llap/parquet_complex_types_vectorization.q.out @@ -213,32 +213,32 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 6:int, val 1000)(children: ListIndexColScalar(col 2:array, col 0:int) -> 6:int) predicate: (l1[0] > 1000) (type: boolean) Statistics: Num rows: 341 Data size: 38920 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: l1[1] (type: int), l1[0] (type: int) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [7, 8] - selectExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 7:int, ListIndexColScalar(col 2:array, col 0:int) -> 8:int + Top N Key Operator + sort order: + + keys: l1[1] (type: int) + null sort order: z Statistics: Num rows: 341 Data size: 38920 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: z - Statistics: Num rows: 341 Data size: 38920 Basic stats: COMPLETE Column stats: NONE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 7:int + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 7:int + native: true + Select Operator + expressions: l1[1] (type: int), l1[0] (type: int) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [6, 8] + selectExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 6:int, ListIndexColScalar(col 2:array, col 0:int) -> 8:int + Statistics: Num rows: 341 Data size: 38920 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: sum(_col1) Group By Vectorization: aggregators: VectorUDAFSumLong(col 8:int) -> bigint className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 7:int + keyExpressions: col 6:int native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0] @@ -523,32 +523,32 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 6:int, val 1000)(children: ListIndexColScalar(col 2:array, col 0:int) -> 6:int) predicate: (l1[0] > 1000) (type: boolean) Statistics: Num rows: 341 Data size: 38921 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: l1[1] (type: int), l1[0] (type: int) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [7, 8] - selectExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 7:int, ListIndexColScalar(col 2:array, col 0:int) -> 8:int + Top N Key Operator + sort order: + + keys: l1[1] (type: int) + null sort order: z Statistics: Num rows: 341 Data size: 38921 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: z - Statistics: Num rows: 341 Data size: 38921 Basic stats: COMPLETE Column stats: NONE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 7:int + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 7:int + native: true + Select Operator + expressions: l1[1] (type: int), l1[0] (type: int) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [6, 8] + selectExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 6:int, ListIndexColScalar(col 2:array, col 0:int) -> 8:int + Statistics: Num rows: 341 Data size: 38921 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: sum(_col1) Group By Vectorization: aggregators: VectorUDAFSumLong(col 8:int) -> bigint className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 7:int + keyExpressions: col 6:int native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0] @@ -833,32 +833,32 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 6:int, val 1000)(children: ListIndexColScalar(col 2:array, col 0:int) -> 6:int) predicate: (l1[0] > 1000) (type: boolean) Statistics: Num rows: 341 Data size: 38923 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: l1[1] (type: int), l1[0] (type: int) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [7, 8] - selectExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 7:int, ListIndexColScalar(col 2:array, col 0:int) -> 8:int + Top N Key Operator + sort order: + + keys: l1[1] (type: int) + null sort order: z Statistics: Num rows: 341 Data size: 38923 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: z - Statistics: Num rows: 341 Data size: 38923 Basic stats: COMPLETE Column stats: NONE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 7:int + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 7:int + native: true + Select Operator + expressions: l1[1] (type: int), l1[0] (type: int) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [6, 8] + selectExpressions: ListIndexColScalar(col 2:array, col 1:int) -> 6:int, ListIndexColScalar(col 2:array, col 0:int) -> 8:int + Statistics: Num rows: 341 Data size: 38923 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: sum(_col1) Group By Vectorization: aggregators: VectorUDAFSumLong(col 8:int) -> bigint className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 7:int + keyExpressions: col 6:int native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0] diff --git ql/src/test/results/clientpositive/llap/parquet_map_type_vectorization.q.out ql/src/test/results/clientpositive/llap/parquet_map_type_vectorization.q.out index 24468c9a1b..797c109957 100644 --- ql/src/test/results/clientpositive/llap/parquet_map_type_vectorization.q.out +++ ql/src/test/results/clientpositive/llap/parquet_map_type_vectorization.q.out @@ -229,32 +229,32 @@ STAGE PLANS: predicateExpression: FilterStringColLikeStringScalar(col 8:string, pattern v100%)(children: VectorUDFMapIndexStringScalar(col 1:map, key: k1) -> 8:string) predicate: (stringmap['k1'] like 'v100%') (type: boolean) Statistics: Num rows: 511 Data size: 995378 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: stringmap['k1'] (type: string), intmap[123] (type: int), doublemap[123.123] (type: double) - outputColumnNames: _col0, _col1, _col2 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [9, 10, 11] - selectExpressions: VectorUDFMapIndexStringScalar(col 1:map, key: k1) -> 9:string, VectorUDFMapIndexLongScalar(col 2:map, key: 123) -> 10:int, VectorUDFMapIndexDecimalScalar(col 3:map, key: 123.123) -> 11:double + Top N Key Operator + sort order: + + keys: stringmap['k1'] (type: string) + null sort order: z Statistics: Num rows: 511 Data size: 995378 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z - Statistics: Num rows: 511 Data size: 995378 Basic stats: COMPLETE Column stats: NONE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 9:string + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: VectorUDFMapIndexStringScalar(col 1:map, key: k1) -> 9:string + native: true + Select Operator + expressions: stringmap['k1'] (type: string), intmap[123] (type: int), doublemap[123.123] (type: double) + outputColumnNames: _col0, _col1, _col2 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [8, 10, 11] + selectExpressions: VectorUDFMapIndexStringScalar(col 1:map, key: k1) -> 8:string, VectorUDFMapIndexLongScalar(col 2:map, key: 123) -> 10:int, VectorUDFMapIndexDecimalScalar(col 3:map, key: 123.123) -> 11:double + Statistics: Num rows: 511 Data size: 995378 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: sum(_col1), sum(_col2) Group By Vectorization: aggregators: VectorUDAFSumLong(col 10:int) -> bigint, VectorUDAFSumDouble(col 11:double) -> double className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 9:string + keyExpressions: col 8:string native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0, 1] diff --git ql/src/test/results/clientpositive/llap/parquet_predicate_pushdown.q.out ql/src/test/results/clientpositive/llap/parquet_predicate_pushdown.q.out index 8c900157c5..3a287bcda8 100644 --- ql/src/test/results/clientpositive/llap/parquet_predicate_pushdown.q.out +++ ql/src/test/results/clientpositive/llap/parquet_predicate_pushdown.q.out @@ -770,17 +770,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 0Y) and (d >= 10.0D) and (d < 12.0D) and UDFToInteger(si) BETWEEN 300 AND 400 and (s like '%son') and (not (s like '%car%'))) (type: boolean) Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs (cache only) Reducer 2 @@ -854,17 +860,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 0Y) and (d >= 10.0D) and (d < 12.0D) and UDFToInteger(si) BETWEEN 300 AND 400 and (s like '%son') and (not (s like '%car%'))) (type: boolean) Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 25 Data size: 2825 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs (cache only) Reducer 2 @@ -1049,17 +1061,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 10Y) and (t <> 101Y) and (d >= 10) and (d < 12.0D) and (s like '%son') and (not (s like '%car%')) and (t > 0Y) and si BETWEEN 300 AND 400) (type: boolean) Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs (cache only) Reducer 2 @@ -1072,13 +1090,19 @@ STAGE PLANS: Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z + Top N Key Operator sort order: - + keys: _col3 (type: string) + null sort order: z Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + top n: 3 + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -1155,17 +1179,23 @@ STAGE PLANS: Filter Operator predicate: ((t > 10Y) and (t <> 101Y) and (d >= 10) and (d < 12.0D) and (s like '%son') and (not (s like '%car%')) and (t > 0Y) and si BETWEEN 300 AND 400) (type: boolean) Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) - outputColumnNames: _col0, _col1, _col2, _col3 + Top N Key Operator + sort order: - + keys: s (type: string) + null sort order: z Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: t (type: tinyint), si (type: smallint), d (type: double), s (type: string) + outputColumnNames: _col0, _col1, _col2, _col3 Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 44 Data size: 4972 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Execution mode: llap LLAP IO: all inputs (cache only) Reducer 2 @@ -1178,13 +1208,19 @@ STAGE PLANS: Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z + Top N Key Operator sort order: - + keys: _col3 (type: string) + null sort order: z Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) + top n: 3 + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: - + Statistics: Num rows: 3 Data size: 339 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: double) Reducer 3 Execution mode: llap Reduce Operator Tree: @@ -1273,17 +1309,23 @@ STAGE PLANS: Filter Operator predicate: ((f < 123.2) and (f > 1.92) and (f >= 9.99) and f BETWEEN 1.92 AND 123.2 and (i < 67627) and (i > 60627) and (i >= 60626) and i BETWEEN 60626 AND 67627 and (b < 4294967861L) and (b > 4294967261L) and (b >= 4294967260L) and b BETWEEN 4294967261L AND 4294967861L) (type: boolean) Statistics: Num rows: 911 Data size: 14576 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: f (type: float), i (type: int), b (type: bigint) - outputColumnNames: _col0, _col1, _col2 + Top N Key Operator + sort order: - + keys: f (type: float) + null sort order: z Statistics: Num rows: 911 Data size: 14576 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: float) - null sort order: z - sort order: - + top n: 3 + Select Operator + expressions: f (type: float), i (type: int), b (type: bigint) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 911 Data size: 14576 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: int), _col2 (type: bigint) + Reduce Output Operator + key expressions: _col0 (type: float) + null sort order: z + sort order: - + Statistics: Num rows: 911 Data size: 14576 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: int), _col2 (type: bigint) Execution mode: llap LLAP IO: all inputs (cache only) Reducer 2 @@ -1296,13 +1338,19 @@ STAGE PLANS: Limit Number of rows: 3 Statistics: Num rows: 3 Data size: 48 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: float) - null sort order: z + Top N Key Operator sort order: - + keys: _col0 (type: float) + null sort order: z Statistics: Num rows: 3 Data size: 48 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: int), _col2 (type: bigint) + top n: 3 + Reduce Output Operator + key expressions: _col0 (type: float) + null sort order: z + sort order: - + Statistics: Num rows: 3 Data size: 48 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: int), _col2 (type: bigint) Reducer 3 Execution mode: llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/parquet_struct_type_vectorization.q.out ql/src/test/results/clientpositive/llap/parquet_struct_type_vectorization.q.out index 45890a1890..3d5dbab011 100644 --- ql/src/test/results/clientpositive/llap/parquet_struct_type_vectorization.q.out +++ ql/src/test/results/clientpositive/llap/parquet_struct_type_vectorization.q.out @@ -237,32 +237,32 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 4:int, val 500)(children: VectorUDFStructField(col 1:struct, col 0:int) -> 4:int) predicate: (st1.f1 > 500) (type: boolean) Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: st1.f1 (type: int) - outputColumnNames: _col0 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [5] - selectExpressions: VectorUDFStructField(col 1:struct, col 0:int) -> 5:int + Top N Key Operator + sort order: + + keys: st1.f1 (type: int) + null sort order: a Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: a - Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 5:int + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: VectorUDFStructField(col 1:struct, col 0:int) -> 5:int + native: true + Select Operator + expressions: st1.f1 (type: int) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [4] + selectExpressions: VectorUDFStructField(col 1:struct, col 0:int) -> 4:int + Statistics: Num rows: 341 Data size: 76542 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: sum(_col0) Group By Vectorization: - aggregators: VectorUDAFSumLong(col 5:int) -> bigint + aggregators: VectorUDAFSumLong(col 4:int) -> bigint className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 5:int + keyExpressions: col 4:int native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0] diff --git ql/src/test/results/clientpositive/llap/q93_with_constraints.q.out ql/src/test/results/clientpositive/llap/q93_with_constraints.q.out index 5bba57633b..5c5a9b5eba 100644 --- ql/src/test/results/clientpositive/llap/q93_with_constraints.q.out +++ ql/src/test/results/clientpositive/llap/q93_with_constraints.q.out @@ -356,12 +356,18 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 285117845 Data size: 34670330027 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col1 (type: decimal(28,2)), _col0 (type: int) - null sort order: zz + Top N Key Operator sort order: ++ + keys: _col1 (type: decimal(28,2)), _col0 (type: int) + null sort order: zz Statistics: Num rows: 285117845 Data size: 34670330027 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + top n: 100 + Reduce Output Operator + key expressions: _col1 (type: decimal(28,2)), _col0 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 285117845 Data size: 34670330027 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Reducer 5 Execution mode: vectorized, llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/smb_mapjoin_15.q.out ql/src/test/results/clientpositive/llap/smb_mapjoin_15.q.out index 8ebc139faa..7ea75a3938 100644 --- ql/src/test/results/clientpositive/llap/smb_mapjoin_15.q.out +++ ql/src/test/results/clientpositive/llap/smb_mapjoin_15.q.out @@ -159,16 +159,22 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3 Position of Big Table: 0 Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z + Top N Key Operator sort order: + + keys: _col0 (type: int) + null sort order: z Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 10 - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string), _col2 (type: int), _col3 (type: string) - auto parallelism: false + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE + tag: -1 + TopN: 10 + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string), _col2 (type: int), _col3 (type: string) + auto parallelism: false Execution mode: llap Path -> Alias: #### A masked pattern was here #### @@ -551,16 +557,22 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Position of Big Table: 0 Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z + Top N Key Operator sort order: + + keys: _col0 (type: int) + null sort order: z Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 10 - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: int), _col2 (type: string), _col3 (type: int), _col4 (type: int), _col5 (type: string) - auto parallelism: false + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE + tag: -1 + TopN: 10 + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: int), _col2 (type: string), _col3 (type: int), _col4 (type: int), _col5 (type: string) + auto parallelism: false Reducer 3 Execution mode: vectorized, llap Needs Tagging: false @@ -834,16 +846,22 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Position of Big Table: 0 Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z + Top N Key Operator sort order: + + keys: _col0 (type: int) + null sort order: z Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 10 - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: int), _col2 (type: string), _col3 (type: int), _col4 (type: int), _col5 (type: string) - auto parallelism: false + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE + tag: -1 + TopN: 10 + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: int), _col2 (type: string), _col3 (type: int), _col4 (type: int), _col5 (type: string) + auto parallelism: false Reducer 3 Execution mode: vectorized, llap Needs Tagging: false @@ -1117,16 +1135,22 @@ STAGE PLANS: outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 Position of Big Table: 0 Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z + Top N Key Operator sort order: + + keys: _col0 (type: int) + null sort order: z Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 10 - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: int), _col2 (type: string), _col3 (type: int), _col4 (type: int), _col5 (type: string) - auto parallelism: false + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: ###Masked### Data size: ###Masked### Basic stats: COMPLETE Column stats: COMPLETE + tag: -1 + TopN: 10 + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: int), _col2 (type: string), _col3 (type: int), _col4 (type: int), _col5 (type: string) + auto parallelism: false Reducer 3 Execution mode: vectorized, llap Needs Tagging: false diff --git ql/src/test/results/clientpositive/llap/subquery_ALL.q.out ql/src/test/results/clientpositive/llap/subquery_ALL.q.out index d910c1a79d..d90d5eafb6 100644 --- ql/src/test/results/clientpositive/llap/subquery_ALL.q.out +++ ql/src/test/results/clientpositive/llap/subquery_ALL.q.out @@ -413,8 +413,8 @@ POSTHOOK: Input: default@part POSTHOOK: Input: default@part_null_n0 #### A masked pattern was here #### 26 -Warning: Shuffle Join MERGEJOIN[36][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product -Warning: Shuffle Join MERGEJOIN[37][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 4' is a cross product +Warning: Shuffle Join MERGEJOIN[37][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[38][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 4' is a cross product PREHOOK: query: select count(*) from part where (p_partkey <> ALL (select p_partkey from part_null_n0 where p_partkey is null)) is null PREHOOK: type: QUERY PREHOOK: Input: default@part diff --git ql/src/test/results/clientpositive/llap/subquery_ANY.q.out ql/src/test/results/clientpositive/llap/subquery_ANY.q.out index 91472d631e..980153ff3b 100644 --- ql/src/test/results/clientpositive/llap/subquery_ANY.q.out +++ ql/src/test/results/clientpositive/llap/subquery_ANY.q.out @@ -320,8 +320,8 @@ POSTHOOK: Input: default@part POSTHOOK: Input: default@part_null_n0 #### A masked pattern was here #### 26 -Warning: Shuffle Join MERGEJOIN[36][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product -Warning: Shuffle Join MERGEJOIN[37][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 4' is a cross product +Warning: Shuffle Join MERGEJOIN[37][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[38][tables = [$hdt$_1, $hdt$_2, $hdt$_0]] in Stage 'Reducer 4' is a cross product PREHOOK: query: select count(*) from part where (p_partkey = ANY (select p_partkey from part_null_n0 where p_partkey is null)) is null PREHOOK: type: QUERY PREHOOK: Input: default@part diff --git ql/src/test/results/clientpositive/llap/subquery_in.q.out ql/src/test/results/clientpositive/llap/subquery_in.q.out index 479e60fda9..24b16598e2 100644 --- ql/src/test/results/clientpositive/llap/subquery_in.q.out +++ ql/src/test/results/clientpositive/llap/subquery_in.q.out @@ -3434,13 +3434,19 @@ STAGE PLANS: 1 _col0 (type: int) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 7 Data size: 4333 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string) - null sort order: z + Top N Key Operator sort order: + + keys: _col3 (type: string) + null sort order: z Statistics: Num rows: 7 Data size: 4333 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string) + top n: 4 + Reduce Output Operator + key expressions: _col3 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 7 Data size: 4333 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/subquery_notin.q.out ql/src/test/results/clientpositive/llap/subquery_notin.q.out index 3dc247591c..6751eda7d3 100644 --- ql/src/test/results/clientpositive/llap/subquery_notin.q.out +++ ql/src/test/results/clientpositive/llap/subquery_notin.q.out @@ -4512,7 +4512,7 @@ POSTHOOK: Input: default@part 78486 almond azure blanched chiffon midnight Manufacturer#5 Brand#52 LARGE BRUSHED BRASS 23 MED BAG 1464.48 hely blith 85768 almond antique chartreuse lavender yellow Manufacturer#1 Brand#12 LARGE BRUSHED STEEL 34 SM BAG 1753.76 refull 90681 almond antique chartreuse khaki white Manufacturer#3 Brand#31 MEDIUM BURNISHED TIN 17 SM CASE 1671.68 are slyly after the sl -Warning: Shuffle Join MERGEJOIN[42][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[43][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product PREHOOK: query: explain select * from part where (p_size-1) NOT IN (select min(p_size) from part group by p_type) order by p_brand, p_partkey limit 4 PREHOOK: type: QUERY PREHOOK: Input: default@part @@ -4615,17 +4615,23 @@ STAGE PLANS: Filter Operator predicate: ((_col12 is null or (_col9 = 0L)) and ((_col10 >= _col9) or (_col9 = 0L) or _col12 is not null or _col5 is null) and (_col5 is not null or (_col9 = 0L) or _col12 is not null)) (type: boolean) Statistics: Num rows: 33 Data size: 20987 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 - Statistics: Num rows: 33 Data size: 20427 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col3 (type: string), _col0 (type: int) - null sort order: zz - sort order: ++ + Top N Key Operator + sort order: ++ + keys: _col3 (type: string), _col0 (type: int) + null sort order: zz + Statistics: Num rows: 33 Data size: 20987 Basic stats: COMPLETE Column stats: COMPLETE + top n: 4 + Select Operator + expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 Statistics: Num rows: 33 Data size: 20427 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string), _col2 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string) + Reduce Output Operator + key expressions: _col3 (type: string), _col0 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 33 Data size: 20427 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string), _col2 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string) Reducer 4 Execution mode: vectorized, llap Reduce Operator Tree: @@ -4721,7 +4727,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join MERGEJOIN[42][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[43][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product PREHOOK: query: select * from part where (p_size-1) NOT IN (select min(p_size) from part group by p_type) order by p_brand, p_partkey limit 4 PREHOOK: type: QUERY PREHOOK: Input: default@part diff --git ql/src/test/results/clientpositive/llap/subquery_scalar.q.out ql/src/test/results/clientpositive/llap/subquery_scalar.q.out index fd65f872c6..13df82e4f0 100644 --- ql/src/test/results/clientpositive/llap/subquery_scalar.q.out +++ ql/src/test/results/clientpositive/llap/subquery_scalar.q.out @@ -1014,7 +1014,7 @@ POSTHOOK: Input: default@part 42669 almond antique medium spring khaki Manufacturer#5 Brand#51 STANDARD BURNISHED TIN 6 MED CAN 1611.66 sits haggl 49671 almond antique gainsboro frosted violet Manufacturer#4 Brand#41 SMALL BRUSHED BRASS 10 SM BOX 1620.67 ccounts run quick 90681 almond antique chartreuse khaki white Manufacturer#3 Brand#31 MEDIUM BURNISHED TIN 17 SM CASE 1671.68 are slyly after the sl -Warning: Shuffle Join MERGEJOIN[24][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[25][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product PREHOOK: query: explain select p_mfgr, p_name, p_size from part where part.p_size > (select first_value(p_size) over(partition by p_mfgr order by p_size) as fv from part order by fv limit 1) @@ -1124,16 +1124,22 @@ STAGE PLANS: window function: GenericUDAFFirstValueEvaluator window frame: RANGE PRECEDING(MAX)~CURRENT Statistics: Num rows: 26 Data size: 9620 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: first_value_window_0 (type: int) - outputColumnNames: _col0 - Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: first_value_window_0 (type: int) + null sort order: z + Statistics: Num rows: 26 Data size: 9620 Basic stats: COMPLETE Column stats: COMPLETE + top n: 1 + Select Operator + expressions: first_value_window_0 (type: int) + outputColumnNames: _col0 Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 5 Execution mode: vectorized, llap Reduce Operator Tree: @@ -1159,7 +1165,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join MERGEJOIN[24][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[25][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product PREHOOK: query: select p_mfgr, p_name, p_size from part where part.p_size > (select first_value(p_size) over(partition by p_mfgr order by p_size) as fv from part order by fv limit 1) diff --git ql/src/test/results/clientpositive/llap/subquery_select.q.out ql/src/test/results/clientpositive/llap/subquery_select.q.out index 9f40436116..4bbbe0ac6f 100644 --- ql/src/test/results/clientpositive/llap/subquery_select.q.out +++ ql/src/test/results/clientpositive/llap/subquery_select.q.out @@ -3071,7 +3071,7 @@ POSTHOOK: Input: default@part 6 false 6 false 7 false -Warning: Shuffle Join MERGEJOIN[15][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[16][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product PREHOOK: query: explain select p_type, (select p_size from part order by p_size limit 1) = 1 from part order by p_type PREHOOK: type: QUERY PREHOOK: Input: default@part @@ -3115,16 +3115,22 @@ STAGE PLANS: TableScan alias: part Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: p_size (type: int) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: p_size (type: int) + null sort order: z Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + + top n: 1 + Select Operator + expressions: p_size (type: int) + outputColumnNames: _col0 Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -3184,7 +3190,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join MERGEJOIN[15][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[16][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product PREHOOK: query: select p_type, (select p_size from part order by p_size limit 1) = 1 from part order by p_type PREHOOK: type: QUERY PREHOOK: Input: default@part @@ -3662,8 +3668,8 @@ POSTHOOK: Input: default@part 6 false 6 false 7 false -Warning: Shuffle Join MERGEJOIN[52][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 5' is a cross product -Warning: Shuffle Join MERGEJOIN[55][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[54][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 5' is a cross product +Warning: Shuffle Join MERGEJOIN[57][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product PREHOOK: query: explain select p_size, (p_size IN (select (select max(p_size) from part) as sb from part order by sb limit 1)) = true from part @@ -3686,11 +3692,12 @@ STAGE PLANS: #### A masked pattern was here #### Edges: Reducer 2 <- Map 1 (SIMPLE_EDGE), Reducer 6 (SIMPLE_EDGE) - Reducer 3 <- Reducer 2 (XPROD_EDGE), Reducer 7 (XPROD_EDGE) + Reducer 3 <- Reducer 2 (XPROD_EDGE), Reducer 8 (XPROD_EDGE) Reducer 4 <- Map 1 (CUSTOM_SIMPLE_EDGE) - Reducer 5 <- Map 8 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE) + Reducer 5 <- Map 9 (CUSTOM_SIMPLE_EDGE), Reducer 4 (CUSTOM_SIMPLE_EDGE) Reducer 6 <- Reducer 5 (SIMPLE_EDGE) - Reducer 7 <- Reducer 6 (CUSTOM_SIMPLE_EDGE) + Reducer 7 <- Reducer 5 (SIMPLE_EDGE) + Reducer 8 <- Reducer 7 (CUSTOM_SIMPLE_EDGE) #### A masked pattern was here #### Vertices: Map 1 @@ -3726,7 +3733,7 @@ STAGE PLANS: value expressions: _col0 (type: int) Execution mode: vectorized, llap LLAP IO: no inputs - Map 8 + Map 9 Map Operator Tree: TableScan alias: part @@ -3801,16 +3808,38 @@ STAGE PLANS: 1 outputColumnNames: _col1 Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col1 (type: int) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: _col1 (type: int) + null sort order: z Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + + top n: 1 + Select Operator + expressions: _col1 (type: int) + outputColumnNames: _col0 Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Top N Key Operator + sort order: + + keys: _col1 (type: int) + null sort order: z + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + top n: 1 + Select Operator + expressions: _col1 (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 6 Execution mode: vectorized, llap Reduce Operator Tree: @@ -3835,6 +3864,16 @@ STAGE PLANS: Map-reduce partition columns: _col0 (type: int) Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE value expressions: _col1 (type: boolean) + Reducer 7 + Execution mode: vectorized, llap + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: int) + outputColumnNames: _col0 + Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + Limit + Number of rows: 1 + Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator aggregations: count(), count(_col0) minReductionHashAggr: 0.0 @@ -3846,7 +3885,7 @@ STAGE PLANS: sort order: Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE value expressions: _col0 (type: bigint), _col1 (type: bigint) - Reducer 7 + Reducer 8 Execution mode: vectorized, llap Reduce Operator Tree: Group By Operator @@ -3870,8 +3909,8 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Shuffle Join MERGEJOIN[52][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 5' is a cross product -Warning: Shuffle Join MERGEJOIN[55][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[54][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 5' is a cross product +Warning: Shuffle Join MERGEJOIN[57][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product PREHOOK: query: select p_size, (p_size IN (select (select max(p_size) from part) as sb from part order by sb limit 1)) = true from part diff --git ql/src/test/results/clientpositive/llap/temp_table.q.out ql/src/test/results/clientpositive/llap/temp_table.q.out index c972b10601..98a5919403 100644 --- ql/src/test/results/clientpositive/llap/temp_table.q.out +++ ql/src/test/results/clientpositive/llap/temp_table.q.out @@ -223,17 +223,23 @@ STAGE PLANS: TableScan alias: foo Statistics: Num rows: 247 Data size: 86848 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 247 Data size: 86848 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 247 Data size: 86848 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 247 Data size: 86848 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 2 @@ -311,13 +317,19 @@ STAGE PLANS: expressions: key (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 247 Data size: 86848 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z + Top N Key Operator sort order: + + keys: _col0 (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 175904 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 175904 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Map 4 @@ -329,13 +341,19 @@ STAGE PLANS: expressions: key (type: string), value (type: string) outputColumnNames: _col0, _col1 Statistics: Num rows: 253 Data size: 89056 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z + Top N Key Operator sort order: + + keys: _col0 (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 175904 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + top n: 10 + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 175904 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Execution mode: vectorized, llap LLAP IO: no inputs Reducer 3 diff --git ql/src/test/results/clientpositive/llap/tez_fixed_bucket_pruning.q.out ql/src/test/results/clientpositive/llap/tez_fixed_bucket_pruning.q.out index 5367d33e0d..87c66395b9 100644 --- ql/src/test/results/clientpositive/llap/tez_fixed_bucket_pruning.q.out +++ ql/src/test/results/clientpositive/llap/tez_fixed_bucket_pruning.q.out @@ -424,7 +424,7 @@ POSTHOOK: type: ANALYZE_TABLE POSTHOOK: Input: default@l3_monthly_dw_dimplan POSTHOOK: Output: default@l3_monthly_dw_dimplan #### A masked pattern was here #### -Warning: Map Join MAPJOIN[48][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[49][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: EXPLAIN EXTENDED SELECT DW.PROJECT_OBJECT_ID, S1.PLAN_KEY as PLAN_KEY, S2.PROJECT_KEY AS PROJECT_KEY FROM l3_clarity__L3_SNAP_NUMBER_2018022300104 snap inner join @@ -547,19 +547,25 @@ STAGE PLANS: 1 Map 5 Position of Big Table: 0 Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col3 (type: bigint), _col5 (type: bigint) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: _col3 (type: bigint), _col5 (type: bigint) + null sort order: zz Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: bigint), _col1 (type: bigint) - null sort order: zz - sort order: ++ - Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 - TopN Hash Memory Usage: 0.1 - auto parallelism: false + top n: 5 + Select Operator + expressions: _col3 (type: bigint), _col5 (type: bigint) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 30 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: bigint), _col1 (type: bigint) + null sort order: zz + sort order: ++ + Statistics: Num rows: 30 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE + tag: -1 + TopN: 5 + TopN Hash Memory Usage: 0.1 + auto parallelism: false Execution mode: vectorized, llap LLAP IO: all inputs Path -> Alias: @@ -854,20 +860,20 @@ STAGE PLANS: Select Operator expressions: KEY.reducesinkkey0 (type: bigint), KEY.reducesinkkey1 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 30 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 5 - Statistics: Num rows: 5 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 48 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: 7147200L (type: bigint), _col0 (type: bigint), _col1 (type: bigint) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 5 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 88 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - Statistics: Num rows: 5 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 88 Basic stats: COMPLETE Column stats: COMPLETE #### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat @@ -891,7 +897,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[48][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[49][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: SELECT DW.PROJECT_OBJECT_ID, S1.PLAN_KEY as PLAN_KEY, S2.PROJECT_KEY AS PROJECT_KEY FROM l3_clarity__L3_SNAP_NUMBER_2018022300104 snap inner join l3_clarity__L3_MONTHLY_DW_FACTPLAN_DW_STG_2018022300104_1 DW on 1=1 @@ -933,7 +939,7 @@ POSTHOOK: Input: default@l3_monthly_dw_dimplan 7147200 195775 27114 7147200 234349 27114 7147200 350519 27114 -Warning: Map Join MAPJOIN[48][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[49][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: EXPLAIN EXTENDED SELECT DW.PROJECT_OBJECT_ID, S1.PLAN_KEY as PLAN_KEY, S2.PROJECT_KEY AS PROJECT_KEY FROM l3_clarity__L3_SNAP_NUMBER_2018022300104 snap inner join @@ -1056,19 +1062,25 @@ STAGE PLANS: 1 Map 5 Position of Big Table: 0 Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col3 (type: bigint), _col5 (type: bigint) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: _col3 (type: bigint), _col5 (type: bigint) + null sort order: zz Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: bigint), _col1 (type: bigint) - null sort order: zz - sort order: ++ - Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 - TopN Hash Memory Usage: 0.1 - auto parallelism: false + top n: 5 + Select Operator + expressions: _col3 (type: bigint), _col5 (type: bigint) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 30 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: bigint), _col1 (type: bigint) + null sort order: zz + sort order: ++ + Statistics: Num rows: 30 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE + tag: -1 + TopN: 5 + TopN Hash Memory Usage: 0.1 + auto parallelism: false Execution mode: vectorized, llap LLAP IO: all inputs Path -> Alias: @@ -1363,20 +1375,20 @@ STAGE PLANS: Select Operator expressions: KEY.reducesinkkey0 (type: bigint), KEY.reducesinkkey1 (type: bigint) outputColumnNames: _col0, _col1 - Statistics: Num rows: 30 Data size: 368 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 30 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 5 - Statistics: Num rows: 5 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 48 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: 7147200L (type: bigint), _col0 (type: bigint), _col1 (type: bigint) outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 5 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 88 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false GlobalTableId: 0 #### A masked pattern was here #### NumFilesPerFileSink: 1 - Statistics: Num rows: 5 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 88 Basic stats: COMPLETE Column stats: COMPLETE #### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat @@ -1400,7 +1412,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[48][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[49][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: SELECT DW.PROJECT_OBJECT_ID, S1.PLAN_KEY as PLAN_KEY, S2.PROJECT_KEY AS PROJECT_KEY FROM l3_clarity__L3_SNAP_NUMBER_2018022300104 snap inner join l3_clarity__L3_MONTHLY_DW_FACTPLAN_DW_STG_2018022300104_1 DW on 1=1 diff --git ql/src/test/results/clientpositive/llap/topnkey.q.out ql/src/test/results/clientpositive/llap/topnkey.q.out index 1e77587f82..3150eefc7d 100644 --- ql/src/test/results/clientpositive/llap/topnkey.q.out +++ ql/src/test/results/clientpositive/llap/topnkey.q.out @@ -1,18 +1,13 @@ -PREHOOK: query: EXPLAIN EXTENDED +PREHOOK: query: EXPLAIN SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: EXPLAIN EXTENDED +POSTHOOK: query: EXPLAIN SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -OPTIMIZED SQL: SELECT `key` AS `$f0`, SUM(CAST(SUBSTR(`value`, 5) AS INTEGER)) AS `$f1` -FROM `default`.`src` -GROUP BY `key` -ORDER BY `key` -LIMIT 5 STAGE DEPENDENCIES: Stage-1 is a root stage Stage-0 depends on stages: Stage-1 @@ -31,17 +26,16 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - GatherStats: false - Select Operator - expressions: key (type: string), UDFToInteger(substr(value, 5)) (type: int) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: z Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z + top n: 5 + Select Operator + expressions: key (type: string), UDFToInteger(substr(value, 5)) (type: int) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 5 Group By Operator aggregations: sum(_col1) keys: _col0 (type: string) @@ -55,69 +49,12 @@ STAGE PLANS: sort order: + Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 TopN Hash Memory Usage: 0.1 value expressions: _col1 (type: bigint) - auto parallelism: true Execution mode: llap LLAP IO: no inputs - Path -> Alias: -#### A masked pattern was here #### - Path -> Partition: -#### A masked pattern was here #### - Partition - base file name: src - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - bucketing_version 2 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - bucketing_version 2 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.src - name: default.src - Truncated Path -> Alias: - /src [src] Reducer 2 Execution mode: llap - Needs Tagging: false Reduce Operator Tree: Group By Operator aggregations: sum(VALUE._col0) @@ -130,14 +67,10 @@ STAGE PLANS: null sort order: z sort order: + Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 TopN Hash Memory Usage: 0.1 value expressions: _col1 (type: bigint) - auto parallelism: false Reducer 3 Execution mode: llap - Needs Tagging: false Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: bigint) @@ -148,26 +81,11 @@ STAGE PLANS: Statistics: Num rows: 5 Data size: 475 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 Statistics: Num rows: 5 Data size: 475 Basic stats: COMPLETE Column stats: COMPLETE -#### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - columns _col0,_col1 - columns.types string:bigint - escape.delim \ - hive.serialization.extend.additional.nesting.levels true - serialization.escape.crlf true - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false Stage: Stage-0 Fetch Operator @@ -175,6 +93,19 @@ STAGE PLANS: Processor Tree: ListSink +PREHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +0 0 +10 10 +100 200 +103 206 +104 208 PREHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -189,12 +120,12 @@ POSTHOOK: Input: default@src 103 206 104 208 PREHOOK: query: EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### POSTHOOK: query: EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### @@ -207,67 +138,108 @@ STAGE PLANS: Tez #### A masked pattern was here #### Edges: - Reducer 2 <- Map 1 (SIMPLE_EDGE) + Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 5 (SIMPLE_EDGE) Reducer 3 <- Reducer 2 (SIMPLE_EDGE) + Reducer 4 <- Reducer 3 (SIMPLE_EDGE) #### A masked pattern was here #### Vertices: Map 1 Map Operator Tree: TableScan - alias: src + alias: src1 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: key (type: string) - outputColumnNames: key + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: a sort order: + - keys: key (type: string) - null sort order: z + Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - top n: 5 - Group By Operator - keys: key (type: string) - minReductionHashAggr: 0.5 - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Execution mode: llap + LLAP IO: no inputs + Map 5 + Map Operator Tree: + TableScan + alias: src2 + filterExpr: key is not null (type: boolean) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + Filter Operator + predicate: key is not null (type: boolean) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: a + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: string) Execution mode: llap LLAP IO: no inputs Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Merge Join Operator + condition map: + Left Outer Join 0 to 1 + keys: + 0 _col0 (type: string) + 1 _col0 (type: string) + outputColumnNames: _col0, _col2 + Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col2 (type: string) + null sort order: za + Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + top n: 5 + Group By Operator + keys: _col0 (type: string), _col2 (type: string) + minReductionHashAggr: 0.0 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: za + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reducer 3 Execution mode: llap Reduce Operator Tree: Group By Operator - keys: KEY._col0 (type: string) + keys: KEY._col0 (type: string), KEY._col1 (type: string) mode: mergepartial - outputColumnNames: _col0 - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE Reduce Output Operator key expressions: _col0 (type: string) null sort order: z sort order: + - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE TopN Hash Memory Usage: 0.1 - Reducer 3 + value expressions: _col1 (type: string) + Reducer 4 Execution mode: llap Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string) - outputColumnNames: _col0 - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 5 - Statistics: Num rows: 5 Data size: 435 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 5 Data size: 435 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -279,33 +251,42 @@ STAGE PLANS: Processor Tree: ListSink -PREHOOK: query: SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -0 -10 -100 -103 -104 -PREHOOK: query: explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -PLAN VECTORIZATION: - enabled: false - enabledConditionsNotMet: [hive.vectorized.execution.enabled IS false] - STAGE DEPENDENCIES: Stage-1 is a root stage Stage-0 depends on stages: Stage-1 @@ -315,19 +296,22 @@ STAGE PLANS: Tez #### A masked pattern was here #### Edges: - Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 4 (SIMPLE_EDGE) + Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 5 (SIMPLE_EDGE) Reducer 3 <- Reducer 2 (SIMPLE_EDGE) + Reducer 4 <- Reducer 3 (SIMPLE_EDGE) #### A masked pattern was here #### Vertices: Map 1 Map Operator Tree: TableScan alias: src1 - filterExpr: key is not null (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator - predicate: key is not null (type: boolean) + Top N Key Operator + sort order: + + keys: key (type: string) + null sort order: a Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + top n: 5 Select Operator expressions: key (type: string) outputColumnNames: _col0 @@ -340,7 +324,7 @@ STAGE PLANS: Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE Execution mode: llap LLAP IO: no inputs - Map 4 + Map 5 Map Operator Tree: TableScan alias: src2 @@ -367,30 +351,53 @@ STAGE PLANS: Reduce Operator Tree: Merge Join Operator condition map: - Inner Join 0 to 1 + Left Outer Join 0 to 1 keys: 0 _col0 (type: string) 1 _col0 (type: string) outputColumnNames: _col0, _col2 Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: string), _col2 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col2 (type: string) + null sort order: aa Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + top n: 5 + Group By Operator + keys: _col0 (type: string), _col2 (type: string) + minReductionHashAggr: 0.0 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: aa + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: a + sort order: + + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) + Reducer 4 Execution mode: llap Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 5 Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE @@ -408,16 +415,276 @@ STAGE PLANS: Processor Tree: ListSink -PREHOOK: query: SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### 0 val_0 -0 val_0 -0 val_0 -0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: CREATE TABLE t_test( + a int, + b int, + c int +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t_test +POSTHOOK: query: CREATE TABLE t_test( + a int, + b int, + c int +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t_test +PREHOOK: query: INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@t_test +POSTHOOK: query: INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@t_test +POSTHOOK: Lineage: t_test.a SCRIPT [] +POSTHOOK: Lineage: t_test.b SCRIPT [] +POSTHOOK: Lineage: t_test.c SCRIPT [] +PREHOOK: query: EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: t_test + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: a (type: int), b (type: int) + null sort order: zz + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + top n: 3 + Select Operator + expressions: a (type: int), b (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Limit + Number of rows: 3 + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: 3 + Processor Tree: + ListSink + +PREHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 1 +5 1 +PREHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 1 +5 1 +PREHOOK: query: EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Tez +#### A masked pattern was here #### + Edges: + Reducer 2 <- Map 1 (SIMPLE_EDGE) + Reducer 3 <- Reducer 2 (SIMPLE_EDGE) +#### A masked pattern was here #### + Vertices: + Map 1 + Map Operator Tree: + TableScan + alias: t_test + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: a (type: int), b (type: int) + null sort order: zz + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + top n: 3 + Select Operator + expressions: a (type: int), b (type: int) + outputColumnNames: a, b + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + keys: a (type: int), b (type: int) + minReductionHashAggr: 0.375 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + null sort order: zz + sort order: ++ + Map-reduce partition columns: _col0 (type: int), _col1 (type: int) + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Execution mode: llap + LLAP IO: no inputs + Reducer 2 + Execution mode: llap + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: int), KEY._col1 (type: int) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reducer 3 + Execution mode: llap + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + Limit + Number of rows: 3 + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: 3 + Processor Tree: + ListSink + +PREHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 2 +6 2 +PREHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 2 +6 2 +PREHOOK: query: DROP TABLE t_test +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@t_test +PREHOOK: Output: default@t_test +POSTHOOK: query: DROP TABLE t_test +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@t_test +POSTHOOK: Output: default@t_test diff --git ql/src/test/results/clientpositive/llap/union_top_level.q.out ql/src/test/results/clientpositive/llap/union_top_level.q.out index ac39cc2622..cf822e3e33 100644 --- ql/src/test/results/clientpositive/llap/union_top_level.q.out +++ ql/src/test/results/clientpositive/llap/union_top_level.q.out @@ -295,17 +295,23 @@ STAGE PLANS: 1 _col0 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col2 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: _col2 (type: string) + null sort order: z Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: _col2 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Reducer 3 Execution mode: vectorized, llap Reduce Operator Tree: @@ -334,17 +340,23 @@ STAGE PLANS: 1 _col0 (type: string) outputColumnNames: _col1, _col2 Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col2 (type: string), _col1 (type: string) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: _col2 (type: string) + null sort order: z Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: _col2 (type: string), _col1 (type: string) + outputColumnNames: _col0, _col1 Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Reducer 6 Execution mode: vectorized, llap Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/llap/vector_case_when_2.q.out ql/src/test/results/clientpositive/llap/vector_case_when_2.q.out index 3501884ce5..bcc7dd2b65 100644 --- ql/src/test/results/clientpositive/llap/vector_case_when_2.q.out +++ ql/src/test/results/clientpositive/llap/vector_case_when_2.q.out @@ -975,28 +975,38 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:q548284:int, 1:ROW__ID:struct] - Select Operator - expressions: q548284 (type: int), CASE WHEN ((q548284 = 1)) THEN (0.2) WHEN ((q548284 = 2)) THEN (0.4) WHEN ((q548284 = 3)) THEN (0.6) WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (null) END (type: decimal(11,1)) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 16] - selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(11,1)col 15:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 1) -> 2:boolean, ConstantVectorExpression(val 0.2) -> 3:decimal(11,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(11,1)col 14:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 2) -> 4:boolean, ConstantVectorExpression(val 0.4) -> 5:decimal(11,1), IfExprCondExprCondExpr(col 6:boolean, col 7:decimal(11,1)col 13:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 3) -> 6:boolean, ConstantVectorExpression(val 0.6) -> 7:decimal(11,1), IfExprCondExprCondExpr(col 8:boolean, col 9:decimal(11,1)col 12:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 8:boolean, ConstantVectorExpression(val 0.8) -> 9:decimal(11,1), IfExprCondExprNull(col 10:boolean, col 11:decimal(11,1), null)(children: LongColEqualLongScalar(col 0:int, val 5) -> 10:boolean, ConstantVectorExpression(val 1) -> 11:decimal(11,1)) -> 12:decimal(11,1)) -> 13:decimal(11,1)) -> 14:decimal(11,1)) -> 15:decimal(11,1)) -> 16:decimal(11,1) + Top N Key Operator + sort order: + + keys: q548284 (type: int) + null sort order: z Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:int + top n: 1 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: q548284 (type: int), CASE WHEN ((q548284 = 1)) THEN (0.2) WHEN ((q548284 = 2)) THEN (0.4) WHEN ((q548284 = 3)) THEN (0.6) WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (null) END (type: decimal(11,1)) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - valueColumns: 16:decimal(11,1) + projectedOutputColumnNums: [0, 16] + selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(11,1)col 15:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 1) -> 2:boolean, ConstantVectorExpression(val 0.2) -> 3:decimal(11,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(11,1)col 14:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 2) -> 4:boolean, ConstantVectorExpression(val 0.4) -> 5:decimal(11,1), IfExprCondExprCondExpr(col 6:boolean, col 7:decimal(11,1)col 13:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 3) -> 6:boolean, ConstantVectorExpression(val 0.6) -> 7:decimal(11,1), IfExprCondExprCondExpr(col 8:boolean, col 9:decimal(11,1)col 12:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 8:boolean, ConstantVectorExpression(val 0.8) -> 9:decimal(11,1), IfExprCondExprNull(col 10:boolean, col 11:decimal(11,1), null)(children: LongColEqualLongScalar(col 0:int, val 5) -> 10:boolean, ConstantVectorExpression(val 1) -> 11:decimal(11,1)) -> 12:decimal(11,1)) -> 13:decimal(11,1)) -> 14:decimal(11,1)) -> 15:decimal(11,1)) -> 16:decimal(11,1) Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: decimal(11,1)) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:int + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 16:decimal(11,1) + Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: decimal(11,1)) Execution mode: vectorized, llap LLAP IO: no inputs Map Vectorization: @@ -1110,28 +1120,38 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:q548284:int, 1:ROW__ID:struct] - Select Operator - expressions: q548284 (type: int), CASE WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (8) END (type: decimal(2,1)) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 8] - selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(2,1)col 7:decimal(2,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 2:boolean, ConstantVectorExpression(val 0.8) -> 3:decimal(2,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(2,1)col 6:decimal(2,1))(children: LongColEqualLongScalar(col 0:int, val 5) -> 4:boolean, ConstantVectorExpression(val 1) -> 5:decimal(2,1), ConstantVectorExpression(val 8) -> 6:decimal(2,1)) -> 7:decimal(2,1)) -> 8:decimal(2,1) + Top N Key Operator + sort order: + + keys: q548284 (type: int) + null sort order: z Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:int + top n: 1 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: q548284 (type: int), CASE WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (8) END (type: decimal(2,1)) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - valueColumns: 8:decimal(2,1) + projectedOutputColumnNums: [0, 8] + selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(2,1)col 7:decimal(2,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 2:boolean, ConstantVectorExpression(val 0.8) -> 3:decimal(2,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(2,1)col 6:decimal(2,1))(children: LongColEqualLongScalar(col 0:int, val 5) -> 4:boolean, ConstantVectorExpression(val 1) -> 5:decimal(2,1), ConstantVectorExpression(val 8) -> 6:decimal(2,1)) -> 7:decimal(2,1)) -> 8:decimal(2,1) Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: decimal(2,1)) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:int + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 8:decimal(2,1) + Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: decimal(2,1)) Execution mode: vectorized, llap LLAP IO: no inputs Map Vectorization: @@ -1245,28 +1265,38 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:q548284:int, 1:ROW__ID:struct] - Select Operator - expressions: q548284 (type: int), CASE WHEN ((q548284 = 1)) THEN (0.2) WHEN ((q548284 = 2)) THEN (0.4) WHEN ((q548284 = 3)) THEN (0.6) WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (null) END (type: decimal(11,1)) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 16] - selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(11,1)col 15:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 1) -> 2:boolean, ConstantVectorExpression(val 0.2) -> 3:decimal(11,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(11,1)col 14:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 2) -> 4:boolean, ConstantVectorExpression(val 0.4) -> 5:decimal(11,1), IfExprCondExprCondExpr(col 6:boolean, col 7:decimal(11,1)col 13:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 3) -> 6:boolean, ConstantVectorExpression(val 0.6) -> 7:decimal(11,1), IfExprCondExprCondExpr(col 8:boolean, col 9:decimal(11,1)col 12:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 8:boolean, ConstantVectorExpression(val 0.8) -> 9:decimal(11,1), IfExprCondExprNull(col 10:boolean, col 11:decimal(11,1), null)(children: LongColEqualLongScalar(col 0:int, val 5) -> 10:boolean, ConstantVectorExpression(val 1) -> 11:decimal(11,1)) -> 12:decimal(11,1)) -> 13:decimal(11,1)) -> 14:decimal(11,1)) -> 15:decimal(11,1)) -> 16:decimal(11,1) + Top N Key Operator + sort order: + + keys: q548284 (type: int) + null sort order: z Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:int + top n: 1 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: q548284 (type: int), CASE WHEN ((q548284 = 1)) THEN (0.2) WHEN ((q548284 = 2)) THEN (0.4) WHEN ((q548284 = 3)) THEN (0.6) WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (null) END (type: decimal(11,1)) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - valueColumns: 16:decimal(11,1) + projectedOutputColumnNums: [0, 16] + selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(11,1)col 15:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 1) -> 2:boolean, ConstantVectorExpression(val 0.2) -> 3:decimal(11,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(11,1)col 14:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 2) -> 4:boolean, ConstantVectorExpression(val 0.4) -> 5:decimal(11,1), IfExprCondExprCondExpr(col 6:boolean, col 7:decimal(11,1)col 13:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 3) -> 6:boolean, ConstantVectorExpression(val 0.6) -> 7:decimal(11,1), IfExprCondExprCondExpr(col 8:boolean, col 9:decimal(11,1)col 12:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 8:boolean, ConstantVectorExpression(val 0.8) -> 9:decimal(11,1), IfExprCondExprNull(col 10:boolean, col 11:decimal(11,1), null)(children: LongColEqualLongScalar(col 0:int, val 5) -> 10:boolean, ConstantVectorExpression(val 1) -> 11:decimal(11,1)) -> 12:decimal(11,1)) -> 13:decimal(11,1)) -> 14:decimal(11,1)) -> 15:decimal(11,1)) -> 16:decimal(11,1) Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: decimal(11,1)) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:int + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 16:decimal(11,1) + Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: decimal(11,1)) Execution mode: vectorized, llap LLAP IO: no inputs Map Vectorization: @@ -1380,28 +1410,38 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:q548284:int, 1:ROW__ID:struct] - Select Operator - expressions: q548284 (type: int), CASE WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (8) END (type: decimal(11,1)) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 8] - selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(11,1)col 7:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 2:boolean, ConstantVectorExpression(val 0.8) -> 3:decimal(11,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(11,1)col 6:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 5) -> 4:boolean, ConstantVectorExpression(val 1) -> 5:decimal(11,1), ConstantVectorExpression(val 8) -> 6:decimal(11,1)) -> 7:decimal(11,1)) -> 8:decimal(11,1) + Top N Key Operator + sort order: + + keys: q548284 (type: int) + null sort order: z Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:int + top n: 1 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: q548284 (type: int), CASE WHEN ((q548284 = 4)) THEN (0.8) WHEN ((q548284 = 5)) THEN (1) ELSE (8) END (type: decimal(11,1)) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - valueColumns: 8:decimal(11,1) + projectedOutputColumnNums: [0, 8] + selectExpressions: IfExprCondExprCondExpr(col 2:boolean, col 3:decimal(11,1)col 7:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 4) -> 2:boolean, ConstantVectorExpression(val 0.8) -> 3:decimal(11,1), IfExprCondExprCondExpr(col 4:boolean, col 5:decimal(11,1)col 6:decimal(11,1))(children: LongColEqualLongScalar(col 0:int, val 5) -> 4:boolean, ConstantVectorExpression(val 1) -> 5:decimal(11,1), ConstantVectorExpression(val 8) -> 6:decimal(11,1)) -> 7:decimal(11,1)) -> 8:decimal(11,1) Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: decimal(11,1)) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:int + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 8:decimal(11,1) + Statistics: Num rows: 6 Data size: 24 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: decimal(11,1)) Execution mode: vectorized, llap LLAP IO: no inputs Map Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_case_when_conversion.q.out ql/src/test/results/clientpositive/llap/vector_case_when_conversion.q.out index 4da58e0c2b..74899062a5 100644 --- ql/src/test/results/clientpositive/llap/vector_case_when_conversion.q.out +++ ql/src/test/results/clientpositive/llap/vector_case_when_conversion.q.out @@ -52,15 +52,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: SelectColumnIsNull(col 5:double) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 6:string, col 2:int, col 4:float, col 1:smallint, IfExprColumnCondExpr(col 13:boolean, col 6:stringcol 23:string)(children: IsNotNull(col 6:string) -> 13:boolean, col 6:string, IfExprCondExprCondExpr(col 14:boolean, col 15:stringcol 22:string)(children: IsNotNull(col 2:int) -> 14:boolean, CastLongToString(col 2:int) -> 15:string, IfExprCondExprCondExpr(col 16:boolean, col 17:stringcol 21:string)(children: IsNotNull(col 4:float) -> 16:boolean, CastFloatToString(col 4:float) -> 17:string, IfExprCondExprColumn(col 18:boolean, col 19:string, col 20:string)(children: IsNotNull(col 1:smallint) -> 18:boolean, CastLongToString(col 1:smallint) -> 19:string, ConstantVectorExpression(val none) -> 20:string) -> 21:string) -> 22:string) -> 23:string) -> 24:string native: true - projectedOutputColumnNums: [6, 2, 4, 1, 24] - selectExpressions: IfExprColumnCondExpr(col 13:boolean, col 6:stringcol 23:string)(children: IsNotNull(col 6:string) -> 13:boolean, col 6:string, IfExprCondExprCondExpr(col 14:boolean, col 15:stringcol 22:string)(children: IsNotNull(col 2:int) -> 14:boolean, CastLongToString(col 2:int) -> 15:string, IfExprCondExprCondExpr(col 16:boolean, col 17:stringcol 21:string)(children: IsNotNull(col 4:float) -> 16:boolean, CastFloatToString(col 4:float) -> 17:string, IfExprCondExprColumn(col 18:boolean, col 19:string, col 20:string)(children: IsNotNull(col 1:smallint) -> 18:boolean, CastLongToString(col 1:smallint) -> 19:string, ConstantVectorExpression(val none) -> 20:string) -> 21:string) -> 22:string) -> 23:string) -> 24:string - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [6, 2, 4, 1, 36] + selectExpressions: IfExprColumnCondExpr(col 25:boolean, col 6:stringcol 35:string)(children: IsNotNull(col 6:string) -> 25:boolean, col 6:string, IfExprCondExprCondExpr(col 26:boolean, col 27:stringcol 34:string)(children: IsNotNull(col 2:int) -> 26:boolean, CastLongToString(col 2:int) -> 27:string, IfExprCondExprCondExpr(col 28:boolean, col 29:stringcol 33:string)(children: IsNotNull(col 4:float) -> 28:boolean, CastFloatToString(col 4:float) -> 29:string, IfExprCondExprColumn(col 30:boolean, col 31:string, col 32:string)(children: IsNotNull(col 1:smallint) -> 30:boolean, CastLongToString(col 1:smallint) -> 31:string, ConstantVectorExpression(val none) -> 32:string) -> 33:string) -> 34:string) -> 35:string) -> 36:string + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -206,15 +210,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: SelectColumnIsTrue(col 13:boolean)(children: VectorUDFAdaptor(cdouble is null) -> 13:boolean) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 6:string, col 2:int, col 4:float, col 1:smallint, VectorUDFAdaptor(CASE WHEN (cstring1 is not null) THEN (cstring1) WHEN (cint is not null) THEN (CAST( cint AS STRING)) WHEN (cfloat is not null) THEN (CAST( cfloat AS STRING)) WHEN (csmallint is not null) THEN (CAST( csmallint AS STRING)) ELSE ('none') END)(children: VectorUDFAdaptor(cstring1 is not null) -> 14:boolean, VectorUDFAdaptor(cint is not null) -> 15:boolean, VectorUDFAdaptor(CAST( cint AS STRING)) -> 16:string, VectorUDFAdaptor(cfloat is not null) -> 17:boolean, VectorUDFAdaptor(CAST( cfloat AS STRING)) -> 18:string, VectorUDFAdaptor(csmallint is not null) -> 19:boolean, VectorUDFAdaptor(CAST( csmallint AS STRING)) -> 20:string) -> 21:string native: true - projectedOutputColumnNums: [6, 2, 4, 1, 21] - selectExpressions: VectorUDFAdaptor(CASE WHEN (cstring1 is not null) THEN (cstring1) WHEN (cint is not null) THEN (CAST( cint AS STRING)) WHEN (cfloat is not null) THEN (CAST( cfloat AS STRING)) WHEN (csmallint is not null) THEN (CAST( csmallint AS STRING)) ELSE ('none') END)(children: VectorUDFAdaptor(cstring1 is not null) -> 14:boolean, VectorUDFAdaptor(cint is not null) -> 15:boolean, VectorUDFAdaptor(CAST( cint AS STRING)) -> 16:string, VectorUDFAdaptor(cfloat is not null) -> 17:boolean, VectorUDFAdaptor(CAST( cfloat AS STRING)) -> 18:string, VectorUDFAdaptor(csmallint is not null) -> 19:boolean, VectorUDFAdaptor(CAST( csmallint AS STRING)) -> 20:string) -> 21:string - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [6, 2, 4, 1, 29] + selectExpressions: VectorUDFAdaptor(CASE WHEN (cstring1 is not null) THEN (cstring1) WHEN (cint is not null) THEN (CAST( cint AS STRING)) WHEN (cfloat is not null) THEN (CAST( cfloat AS STRING)) WHEN (csmallint is not null) THEN (CAST( csmallint AS STRING)) ELSE ('none') END)(children: VectorUDFAdaptor(cstring1 is not null) -> 22:boolean, VectorUDFAdaptor(cint is not null) -> 23:boolean, VectorUDFAdaptor(CAST( cint AS STRING)) -> 24:string, VectorUDFAdaptor(cfloat is not null) -> 25:boolean, VectorUDFAdaptor(CAST( cfloat AS STRING)) -> 26:string, VectorUDFAdaptor(csmallint is not null) -> 27:boolean, VectorUDFAdaptor(CAST( csmallint AS STRING)) -> 28:string) -> 29:string + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -360,15 +368,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: SelectColumnIsNull(col 5:double) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 6:string, col 2:int, col 4:float, col 1:smallint, IfExprColumnCondExpr(col 13:boolean, col 6:stringcol 22:string)(children: IsNotNull(col 6:string) -> 13:boolean, col 6:string, IfExprCondExprCondExpr(col 14:boolean, col 15:stringcol 21:string)(children: IsNotNull(col 2:int) -> 14:boolean, CastLongToString(col 2:int) -> 15:string, IfExprCondExprCondExpr(col 16:boolean, col 17:stringcol 20:string)(children: IsNotNull(col 4:float) -> 16:boolean, CastFloatToString(col 4:float) -> 17:string, IfExprCondExprNull(col 18:boolean, col 19:string, null)(children: IsNotNull(col 1:smallint) -> 18:boolean, CastLongToString(col 1:smallint) -> 19:string) -> 20:string) -> 21:string) -> 22:string) -> 23:string native: true - projectedOutputColumnNums: [6, 2, 4, 1, 23] - selectExpressions: IfExprColumnCondExpr(col 13:boolean, col 6:stringcol 22:string)(children: IsNotNull(col 6:string) -> 13:boolean, col 6:string, IfExprCondExprCondExpr(col 14:boolean, col 15:stringcol 21:string)(children: IsNotNull(col 2:int) -> 14:boolean, CastLongToString(col 2:int) -> 15:string, IfExprCondExprCondExpr(col 16:boolean, col 17:stringcol 20:string)(children: IsNotNull(col 4:float) -> 16:boolean, CastFloatToString(col 4:float) -> 17:string, IfExprCondExprNull(col 18:boolean, col 19:string, null)(children: IsNotNull(col 1:smallint) -> 18:boolean, CastLongToString(col 1:smallint) -> 19:string) -> 20:string) -> 21:string) -> 22:string) -> 23:string - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [6, 2, 4, 1, 34] + selectExpressions: IfExprColumnCondExpr(col 24:boolean, col 6:stringcol 33:string)(children: IsNotNull(col 6:string) -> 24:boolean, col 6:string, IfExprCondExprCondExpr(col 25:boolean, col 26:stringcol 32:string)(children: IsNotNull(col 2:int) -> 25:boolean, CastLongToString(col 2:int) -> 26:string, IfExprCondExprCondExpr(col 27:boolean, col 28:stringcol 31:string)(children: IsNotNull(col 4:float) -> 27:boolean, CastFloatToString(col 4:float) -> 28:string, IfExprCondExprNull(col 29:boolean, col 30:string, null)(children: IsNotNull(col 1:smallint) -> 29:boolean, CastLongToString(col 1:smallint) -> 30:string) -> 31:string) -> 32:string) -> 33:string) -> 34:string + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -514,15 +526,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: SelectColumnIsTrue(col 13:boolean)(children: VectorUDFAdaptor(cdouble is null) -> 13:boolean) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 6:string, col 2:int, col 4:float, col 1:smallint, VectorUDFAdaptor(CASE WHEN (cstring1 is not null) THEN (cstring1) WHEN (cint is not null) THEN (CAST( cint AS STRING)) WHEN (cfloat is not null) THEN (CAST( cfloat AS STRING)) WHEN (csmallint is not null) THEN (CAST( csmallint AS STRING)) ELSE (null) END)(children: VectorUDFAdaptor(cstring1 is not null) -> 14:boolean, VectorUDFAdaptor(cint is not null) -> 15:boolean, VectorUDFAdaptor(CAST( cint AS STRING)) -> 16:string, VectorUDFAdaptor(cfloat is not null) -> 17:boolean, VectorUDFAdaptor(CAST( cfloat AS STRING)) -> 18:string, VectorUDFAdaptor(csmallint is not null) -> 19:boolean, VectorUDFAdaptor(CAST( csmallint AS STRING)) -> 20:string) -> 21:string native: true - projectedOutputColumnNums: [6, 2, 4, 1, 21] - selectExpressions: VectorUDFAdaptor(CASE WHEN (cstring1 is not null) THEN (cstring1) WHEN (cint is not null) THEN (CAST( cint AS STRING)) WHEN (cfloat is not null) THEN (CAST( cfloat AS STRING)) WHEN (csmallint is not null) THEN (CAST( csmallint AS STRING)) ELSE (null) END)(children: VectorUDFAdaptor(cstring1 is not null) -> 14:boolean, VectorUDFAdaptor(cint is not null) -> 15:boolean, VectorUDFAdaptor(CAST( cint AS STRING)) -> 16:string, VectorUDFAdaptor(cfloat is not null) -> 17:boolean, VectorUDFAdaptor(CAST( cfloat AS STRING)) -> 18:string, VectorUDFAdaptor(csmallint is not null) -> 19:boolean, VectorUDFAdaptor(CAST( csmallint AS STRING)) -> 20:string) -> 21:string - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [6, 2, 4, 1, 29] + selectExpressions: VectorUDFAdaptor(CASE WHEN (cstring1 is not null) THEN (cstring1) WHEN (cint is not null) THEN (CAST( cint AS STRING)) WHEN (cfloat is not null) THEN (CAST( cfloat AS STRING)) WHEN (csmallint is not null) THEN (CAST( csmallint AS STRING)) ELSE (null) END)(children: VectorUDFAdaptor(cstring1 is not null) -> 22:boolean, VectorUDFAdaptor(cint is not null) -> 23:boolean, VectorUDFAdaptor(CAST( cint AS STRING)) -> 24:string, VectorUDFAdaptor(cfloat is not null) -> 25:boolean, VectorUDFAdaptor(CAST( cfloat AS STRING)) -> 26:string, VectorUDFAdaptor(csmallint is not null) -> 27:boolean, VectorUDFAdaptor(CAST( csmallint AS STRING)) -> 28:string) -> 29:string + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out index cc2dc47280..bedae4d20b 100644 --- ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out +++ ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out @@ -137,24 +137,24 @@ STAGE PLANS: Statistics: Num rows: 1049 Data size: 4196 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: i (type: int) - outputColumnNames: _col0 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [2] + Top N Key Operator + sort order: + + keys: i (type: int) + null sort order: z Statistics: Num rows: 1049 Data size: 4196 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: int) - null sort order: z - Statistics: Num rows: 1049 Data size: 4196 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 2:int + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 2:int + native: true + Select Operator + expressions: i (type: int) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [2] + Statistics: Num rows: 1049 Data size: 4196 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator aggregations: sum(50), count(), sum(50.0D), count(50.0D), sum(50), count(50) Group By Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_char_2.q.out ql/src/test/results/clientpositive/llap/vector_char_2.q.out index f7e76e5a8b..ec47404513 100644 --- ql/src/test/results/clientpositive/llap/vector_char_2.q.out +++ ql/src/test/results/clientpositive/llap/vector_char_2.q.out @@ -97,25 +97,25 @@ STAGE PLANS: Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: value (type: char(20)), UDFToInteger(key) (type: int) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [1, 3] - selectExpressions: CastStringToLong(col 0:char(10)) -> 3:int + Top N Key Operator + sort order: + + keys: value (type: char(20)) + null sort order: z Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: char(20)) - null sort order: z - Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE - top n: 5 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 1:char(20) + top n: 5 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 1:char(20) + native: true + Select Operator + expressions: value (type: char(20)), UDFToInteger(key) (type: int) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [1, 3] + selectExpressions: CastStringToLong(col 0:char(10)) -> 3:int + Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator aggregations: sum(_col1), count() Group By Vectorization: @@ -310,25 +310,25 @@ STAGE PLANS: Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: value (type: char(20)), UDFToInteger(key) (type: int) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [1, 3] - selectExpressions: CastStringToLong(col 0:char(10)) -> 3:int + Top N Key Operator + sort order: - + keys: value (type: char(20)) + null sort order: z Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: - - keys: _col0 (type: char(20)) - null sort order: z - Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE - top n: 5 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 1:char(20) + top n: 5 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 1:char(20) + native: true + Select Operator + expressions: value (type: char(20)), UDFToInteger(key) (type: int) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [1, 3] + selectExpressions: CastStringToLong(col 0:char(10)) -> 3:int + Statistics: Num rows: 501 Data size: 89178 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator aggregations: sum(_col1), count() Group By Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_coalesce.q.out ql/src/test/results/clientpositive/llap/vector_coalesce.q.out index 9573b3db77..d767d7dc21 100644 --- ql/src/test/results/clientpositive/llap/vector_coalesce.q.out +++ ql/src/test/results/clientpositive/llap/vector_coalesce.q.out @@ -36,15 +36,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: SelectColumnIsNull(col 5:double) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 6:string, col 2:int, col 4:float, col 1:smallint, IfExprColumnCondExpr(col 13:boolean, col 6:stringcol 20:string)(children: IsNotNull(col 6:string) -> 13:boolean, col 6:string, IfExprCondExprCondExpr(col 14:boolean, col 15:stringcol 19:string)(children: IsNotNull(col 2:int) -> 14:boolean, CastLongToString(col 2:int) -> 15:string, IfExprCondExprCondExpr(col 16:boolean, col 17:stringcol 18:string)(children: IsNotNull(col 4:float) -> 16:boolean, CastFloatToString(col 4:float) -> 17:string, CastLongToString(col 1:smallint) -> 18:string) -> 19:string) -> 20:string) -> 21:string native: true - projectedOutputColumnNums: [6, 2, 4, 1, 21] - selectExpressions: IfExprColumnCondExpr(col 13:boolean, col 6:stringcol 20:string)(children: IsNotNull(col 6:string) -> 13:boolean, col 6:string, IfExprCondExprCondExpr(col 14:boolean, col 15:stringcol 19:string)(children: IsNotNull(col 2:int) -> 14:boolean, CastLongToString(col 2:int) -> 15:string, IfExprCondExprCondExpr(col 16:boolean, col 17:stringcol 18:string)(children: IsNotNull(col 4:float) -> 16:boolean, CastFloatToString(col 4:float) -> 17:string, CastLongToString(col 1:smallint) -> 18:string) -> 19:string) -> 20:string) -> 21:string - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [6, 2, 4, 1, 30] + selectExpressions: IfExprColumnCondExpr(col 22:boolean, col 6:stringcol 29:string)(children: IsNotNull(col 6:string) -> 22:boolean, col 6:string, IfExprCondExprCondExpr(col 23:boolean, col 24:stringcol 28:string)(children: IsNotNull(col 2:int) -> 23:boolean, CastLongToString(col 2:int) -> 24:string, IfExprCondExprCondExpr(col 25:boolean, col 26:stringcol 27:string)(children: IsNotNull(col 4:float) -> 25:boolean, CastFloatToString(col 4:float) -> 26:string, CastLongToString(col 1:smallint) -> 27:string) -> 28:string) -> 29:string) -> 30:string + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -148,15 +152,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: SelectColumnIsNull(col 0:tinyint) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 5:double, col 2:int, IfExprCondExprColumn(col 16:boolean, col 18:double, col 19:double)(children: ColAndCol(col 13:boolean, col 15:boolean)(children: IsNotNull(col 5:double) -> 13:boolean, IsNotNull(col 14:double)(children: FuncLog2LongToDouble(col 2:int) -> 14:double) -> 15:boolean) -> 16:boolean, DoubleColAddDoubleColumn(col 5:double, col 17:double)(children: FuncLog2LongToDouble(col 2:int) -> 17:double) -> 18:double, ConstantVectorExpression(val 0.0) -> 19:double) -> 20:double native: true - projectedOutputColumnNums: [5, 2, 20] - selectExpressions: IfExprCondExprColumn(col 16:boolean, col 18:double, col 19:double)(children: ColAndCol(col 13:boolean, col 15:boolean)(children: IsNotNull(col 5:double) -> 13:boolean, IsNotNull(col 14:double)(children: FuncLog2LongToDouble(col 2:int) -> 14:double) -> 15:boolean) -> 16:boolean, DoubleColAddDoubleColumn(col 5:double, col 17:double)(children: FuncLog2LongToDouble(col 2:int) -> 17:double) -> 18:double, ConstantVectorExpression(val 0.0) -> 19:double) -> 20:double - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [5, 2, 28] + selectExpressions: IfExprCondExprColumn(col 24:boolean, col 26:double, col 27:double)(children: ColAndCol(col 21:boolean, col 23:boolean)(children: IsNotNull(col 5:double) -> 21:boolean, IsNotNull(col 22:double)(children: FuncLog2LongToDouble(col 2:int) -> 22:double) -> 23:boolean) -> 24:boolean, DoubleColAddDoubleColumn(col 5:double, col 25:double)(children: FuncLog2LongToDouble(col 2:int) -> 25:double) -> 26:double, ConstantVectorExpression(val 0.0) -> 27:double) -> 28:double + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -348,15 +356,19 @@ STAGE PLANS: className: VectorFilterOperator native: true predicateExpression: FilterExprOrExpr(children: SelectColumnIsNotNull(col 9:timestamp), SelectColumnIsNotNull(col 8:timestamp)) - Select Vectorization: - className: VectorSelectOperator + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 8:timestamp, col 9:timestamp, IfExprTimestampColumnColumn(col 13:boolean, col 8:timestampcol 9:timestamp)(children: IsNotNull(col 8:timestamp) -> 13:boolean) -> 14:timestamp native: true - projectedOutputColumnNums: [8, 9, 14] - selectExpressions: IfExprTimestampColumnColumn(col 13:boolean, col 8:timestampcol 9:timestamp)(children: IsNotNull(col 8:timestamp) -> 13:boolean) -> 14:timestamp - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [8, 9, 16] + selectExpressions: IfExprTimestampColumnColumn(col 15:boolean, col 8:timestampcol 9:timestamp)(children: IsNotNull(col 8:timestamp) -> 15:boolean) -> 16:timestamp + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_data_types.q.out ql/src/test/results/clientpositive/llap/vector_data_types.q.out index df9c3499bf..718daea797 100644 --- ql/src/test/results/clientpositive/llap/vector_data_types.q.out +++ ql/src/test/results/clientpositive/llap/vector_data_types.q.out @@ -139,17 +139,23 @@ STAGE PLANS: TableScan alias: over1korc_n1 Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float), d (type: double), bo (type: boolean), s (type: string), ts (type: timestamp), dec (type: decimal(4,2)), bin (type: binary) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + Top N Key Operator + sort order: +++ + keys: t (type: tinyint), si (type: smallint), i (type: int) + null sort order: zzz Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: int) - null sort order: zzz - sort order: +++ - Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col3 (type: bigint), _col4 (type: float), _col5 (type: double), _col6 (type: boolean), _col7 (type: string), _col8 (type: timestamp), _col9 (type: decimal(4,2)), _col10 (type: binary) + top n: 20 + Select Operator + expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float), d (type: double), bo (type: boolean), s (type: string), ts (type: timestamp), dec (type: decimal(4,2)), bin (type: binary) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + Statistics: Num rows: 1050 Data size: 357661 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: int) + null sort order: zzz + sort order: +++ + Statistics: Num rows: 1050 Data size: 357661 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col3 (type: bigint), _col4 (type: float), _col5 (type: double), _col6 (type: boolean), _col7 (type: string), _col8 (type: timestamp), _col9 (type: decimal(4,2)), _col10 (type: binary) Execution mode: llap LLAP IO: all inputs Reducer 2 @@ -158,7 +164,7 @@ STAGE PLANS: Select Operator expressions: KEY.reducesinkkey0 (type: tinyint), KEY.reducesinkkey1 (type: smallint), KEY.reducesinkkey2 (type: int), VALUE._col0 (type: bigint), VALUE._col1 (type: float), VALUE._col2 (type: double), VALUE._col3 (type: boolean), VALUE._col4 (type: string), VALUE._col5 (type: timestamp), VALUE._col6 (type: decimal(4,2)), VALUE._col7 (type: binary) outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 - Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 1050 Data size: 357661 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Statistics: Num rows: 20 Data size: 6820 Basic stats: COMPLETE Column stats: COMPLETE @@ -246,25 +252,35 @@ STAGE PLANS: Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float), d (type: double), bo (type: boolean), s (type: string), ts (type: timestamp), dec (type: decimal(4,2)), bin (type: binary) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + Top N Key Operator + sort order: +++ + keys: t (type: tinyint), si (type: smallint), i (type: int) + null sort order: zzz Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: int) - null sort order: zzz - sort order: +++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint, col 1:smallint, col 2:int + native: true + Select Operator + expressions: t (type: tinyint), si (type: smallint), i (type: int), b (type: bigint), f (type: float), d (type: double), bo (type: boolean), s (type: string), ts (type: timestamp), dec (type: decimal(4,2)), bin (type: binary) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col3 (type: bigint), _col4 (type: float), _col5 (type: double), _col6 (type: boolean), _col7 (type: string), _col8 (type: timestamp), _col9 (type: decimal(4,2)), _col10 (type: binary) + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] + Statistics: Num rows: 1050 Data size: 357661 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint), _col1 (type: smallint), _col2 (type: int) + null sort order: zzz + sort order: +++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 1050 Data size: 357661 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col3 (type: bigint), _col4 (type: float), _col5 (type: double), _col6 (type: boolean), _col7 (type: string), _col8 (type: timestamp), _col9 (type: decimal(4,2)), _col10 (type: binary) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -292,7 +308,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] - Statistics: Num rows: 1050 Data size: 358026 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 1050 Data size: 357661 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_decimal_expressions.q.out ql/src/test/results/clientpositive/llap/vector_decimal_expressions.q.out index 8500562893..73b87efcbd 100644 --- ql/src/test/results/clientpositive/llap/vector_decimal_expressions.q.out +++ ql/src/test/results/clientpositive/llap/vector_decimal_expressions.q.out @@ -74,26 +74,36 @@ STAGE PLANS: predicateExpression: FilterExprAndExpr(children: FilterDecimalColGreaterDecimalScalar(col 1:decimal(20,10), val 0), FilterDecimalColLessDecimalScalar(col 1:decimal(20,10), val 12345.5678), FilterDecimalColGreaterDecimalScalar(col 2:decimal(23,14), val 1000), SelectColumnIsNotNull(col 0:double), FilterDecimalColNotEqualDecimalScalar(col 2:decimal(23,14), val 0)) predicate: ((cdecimal1 > 0) and (cdecimal1 < 12345.5678) and (cdecimal2 > 1000) and cdouble is not null and (cdecimal2 <> 0)) (type: boolean) Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: (cdecimal1 + cdecimal2) (type: decimal(25,14)), (cdecimal1 - (2 * cdecimal2)) (type: decimal(26,14)), ((cdecimal1 + 2.34) / cdecimal2) (type: decimal(38,13)), (cdecimal1 * (cdecimal2 / 3.4)) (type: decimal(38,17)), (cdecimal1 % 10) (type: decimal(12,10)), UDFToInteger(cdecimal1) (type: int), UDFToShort(cdecimal2) (type: smallint), UDFToByte(cdecimal2) (type: tinyint), UDFToLong(cdecimal1) (type: bigint), UDFToBoolean(cdecimal1) (type: boolean), UDFToDouble(cdecimal2) (type: double), UDFToFloat(cdecimal1) (type: float), CAST( cdecimal2 AS STRING) (type: string), CAST( cdecimal1 AS TIMESTAMP) (type: timestamp) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [4, 6, 8, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] - selectExpressions: DecimalColAddDecimalColumn(col 1:decimal(20,10), col 2:decimal(23,14)) -> 4:decimal(25,14), DecimalColSubtractDecimalColumn(col 1:decimal(20,10), col 5:decimal(25,14))(children: DecimalScalarMultiplyDecimalColumn(val 2, col 2:decimal(23,14)) -> 5:decimal(25,14)) -> 6:decimal(26,14), DecimalColDivideDecimalColumn(col 7:decimal(21,10), col 2:decimal(23,14))(children: DecimalColAddDecimalScalar(col 1:decimal(20,10), val 2.34) -> 7:decimal(21,10)) -> 8:decimal(38,13), DecimalColMultiplyDecimalColumn(col 1:decimal(20,10), col 9:decimal(27,17))(children: DecimalColDivideDecimalScalar(col 2:decimal(23,14), val 3.4) -> 9:decimal(27,17)) -> 10:decimal(38,17), DecimalColModuloDecimalScalar(col 1:decimal(20,10), val 10) -> 11:decimal(12,10), CastDecimalToLong(col 1:decimal(20,10)) -> 12:int, CastDecimalToLong(col 2:decimal(23,14)) -> 13:smallint, CastDecimalToLong(col 2:decimal(23,14)) -> 14:tinyint, CastDecimalToLong(col 1:decimal(20,10)) -> 15:bigint, CastDecimalToBoolean(col 1:decimal(20,10)) -> 16:boolean, CastDecimalToDouble(col 2:decimal(23,14)) -> 17:double, CastDecimalToFloat(col 1:decimal(20,10)) -> 18:float, CastDecimalToString(col 2:decimal(23,14)) -> 19:string, CastDecimalToTimestamp(col 1:decimal(20,10)) -> 20:timestamp + Top N Key Operator + sort order: ++++++++++++++ + keys: (cdecimal1 + cdecimal2) (type: decimal(25,14)), (cdecimal1 - (2 * cdecimal2)) (type: decimal(26,14)), ((cdecimal1 + 2.34) / cdecimal2) (type: decimal(38,13)), (cdecimal1 * (cdecimal2 / 3.4)) (type: decimal(38,17)), (cdecimal1 % 10) (type: decimal(12,10)), UDFToInteger(cdecimal1) (type: int), UDFToShort(cdecimal2) (type: smallint), UDFToByte(cdecimal2) (type: tinyint), UDFToLong(cdecimal1) (type: bigint), UDFToBoolean(cdecimal1) (type: boolean), UDFToDouble(cdecimal2) (type: double), UDFToFloat(cdecimal1) (type: float), CAST( cdecimal2 AS STRING) (type: string), CAST( cdecimal1 AS TIMESTAMP) (type: timestamp) + null sort order: zzzzzzzzzzzzzz Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: decimal(25,14)), _col1 (type: decimal(26,14)), _col2 (type: decimal(38,13)), _col3 (type: decimal(38,17)), _col4 (type: decimal(12,10)), _col5 (type: int), _col6 (type: smallint), _col7 (type: tinyint), _col8 (type: bigint), _col9 (type: boolean), _col10 (type: double), _col11 (type: float), _col12 (type: string), _col13 (type: timestamp) - null sort order: zzzzzzzzzzzzzz - sort order: ++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 4:decimal(25,14), 6:decimal(26,14), 8:decimal(38,13), 10:decimal(38,17), 11:decimal(12,10), 12:int, 13:smallint, 14:tinyint, 15:bigint, 16:boolean, 17:double, 18:float, 19:string, 20:timestamp + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: DecimalColAddDecimalColumn(col 1:decimal(20,10), col 2:decimal(23,14)) -> 4:decimal(25,14), DecimalColSubtractDecimalColumn(col 1:decimal(20,10), col 5:decimal(25,14))(children: DecimalScalarMultiplyDecimalColumn(val 2, col 2:decimal(23,14)) -> 5:decimal(25,14)) -> 6:decimal(26,14), DecimalColDivideDecimalColumn(col 7:decimal(21,10), col 2:decimal(23,14))(children: DecimalColAddDecimalScalar(col 1:decimal(20,10), val 2.34) -> 7:decimal(21,10)) -> 8:decimal(38,13), DecimalColMultiplyDecimalColumn(col 1:decimal(20,10), col 9:decimal(27,17))(children: DecimalColDivideDecimalScalar(col 2:decimal(23,14), val 3.4) -> 9:decimal(27,17)) -> 10:decimal(38,17), DecimalColModuloDecimalScalar(col 1:decimal(20,10), val 10) -> 11:decimal(12,10), CastDecimalToLong(col 1:decimal(20,10)) -> 12:int, CastDecimalToLong(col 2:decimal(23,14)) -> 13:smallint, CastDecimalToLong(col 2:decimal(23,14)) -> 14:tinyint, CastDecimalToLong(col 1:decimal(20,10)) -> 15:bigint, CastDecimalToBoolean(col 1:decimal(20,10)) -> 16:boolean, CastDecimalToDouble(col 2:decimal(23,14)) -> 17:double, CastDecimalToFloat(col 1:decimal(20,10)) -> 18:float, CastDecimalToString(col 2:decimal(23,14)) -> 19:string, CastDecimalToTimestamp(col 1:decimal(20,10)) -> 20:timestamp + native: true + Select Operator + expressions: (cdecimal1 + cdecimal2) (type: decimal(25,14)), (cdecimal1 - (2 * cdecimal2)) (type: decimal(26,14)), ((cdecimal1 + 2.34) / cdecimal2) (type: decimal(38,13)), (cdecimal1 * (cdecimal2 / 3.4)) (type: decimal(38,17)), (cdecimal1 % 10) (type: decimal(12,10)), UDFToInteger(cdecimal1) (type: int), UDFToShort(cdecimal2) (type: smallint), UDFToByte(cdecimal2) (type: tinyint), UDFToLong(cdecimal1) (type: bigint), UDFToBoolean(cdecimal1) (type: boolean), UDFToDouble(cdecimal2) (type: double), UDFToFloat(cdecimal1) (type: float), CAST( cdecimal2 AS STRING) (type: string), CAST( cdecimal1 AS TIMESTAMP) (type: timestamp) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [21, 23, 25, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37] + selectExpressions: DecimalColAddDecimalColumn(col 1:decimal(20,10), col 2:decimal(23,14)) -> 21:decimal(25,14), DecimalColSubtractDecimalColumn(col 1:decimal(20,10), col 22:decimal(25,14))(children: DecimalScalarMultiplyDecimalColumn(val 2, col 2:decimal(23,14)) -> 22:decimal(25,14)) -> 23:decimal(26,14), DecimalColDivideDecimalColumn(col 24:decimal(21,10), col 2:decimal(23,14))(children: DecimalColAddDecimalScalar(col 1:decimal(20,10), val 2.34) -> 24:decimal(21,10)) -> 25:decimal(38,13), DecimalColMultiplyDecimalColumn(col 1:decimal(20,10), col 26:decimal(27,17))(children: DecimalColDivideDecimalScalar(col 2:decimal(23,14), val 3.4) -> 26:decimal(27,17)) -> 27:decimal(38,17), DecimalColModuloDecimalScalar(col 1:decimal(20,10), val 10) -> 28:decimal(12,10), CastDecimalToLong(col 1:decimal(20,10)) -> 29:int, CastDecimalToLong(col 2:decimal(23,14)) -> 30:smallint, CastDecimalToLong(col 2:decimal(23,14)) -> 31:tinyint, CastDecimalToLong(col 1:decimal(20,10)) -> 32:bigint, CastDecimalToBoolean(col 1:decimal(20,10)) -> 33:boolean, CastDecimalToDouble(col 2:decimal(23,14)) -> 34:double, CastDecimalToFloat(col 1:decimal(20,10)) -> 35:float, CastDecimalToString(col 2:decimal(23,14)) -> 36:string, CastDecimalToTimestamp(col 1:decimal(20,10)) -> 37:timestamp Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: decimal(25,14)), _col1 (type: decimal(26,14)), _col2 (type: decimal(38,13)), _col3 (type: decimal(38,17)), _col4 (type: decimal(12,10)), _col5 (type: int), _col6 (type: smallint), _col7 (type: tinyint), _col8 (type: bigint), _col9 (type: boolean), _col10 (type: double), _col11 (type: float), _col12 (type: string), _col13 (type: timestamp) + null sort order: zzzzzzzzzzzzzz + sort order: ++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 21:decimal(25,14), 23:decimal(26,14), 25:decimal(38,13), 27:decimal(38,17), 28:decimal(12,10), 29:int, 30:smallint, 31:tinyint, 32:bigint, 33:boolean, 34:double, 35:float, 36:string, 37:timestamp + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -110,7 +120,7 @@ STAGE PLANS: includeColumns: [0, 1, 2] dataColumns: cdouble:double, cdecimal1:decimal(20,10), cdecimal2:decimal(23,14) partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(25,14), decimal(25,14), decimal(26,14), decimal(21,10), decimal(38,13), decimal(27,17), decimal(38,17), decimal(12,10), bigint, bigint, bigint, bigint, bigint, double, double, string, timestamp] + scratchColumnTypeNames: [decimal(25,14), decimal(25,14), decimal(26,14), decimal(21,10), decimal(38,13), decimal(27,17), decimal(38,17), decimal(12,10), bigint, bigint, bigint, bigint, bigint, double, double, string, timestamp, decimal(25,14), decimal(25,14), decimal(26,14), decimal(21,10), decimal(38,13), decimal(27,17), decimal(38,17), decimal(12,10), bigint, bigint, bigint, bigint, bigint, double, double, string, timestamp] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -252,26 +262,36 @@ STAGE PLANS: predicateExpression: FilterExprAndExpr(children: FilterDecimal64ColGreaterDecimal64Scalar(col 1:decimal(10,3)/DECIMAL_64, val 0), FilterDecimalColLessDecimalScalar(col 4:decimal(10,3), val 12345.5678)(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)), FilterDecimal64ColGreaterDecimal64Scalar(col 2:decimal(7,2)/DECIMAL_64, val 100000), SelectColumnIsNotNull(col 0:double), FilterDecimal64ColNotEqualDecimal64Scalar(col 2:decimal(7,2)/DECIMAL_64, val 0)) predicate: ((cdecimal1 > 0) and (cdecimal1 < 12345.5678) and (cdecimal2 > 1000) and cdouble is not null and (cdecimal2 <> 0)) (type: boolean) Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: (cdecimal1 + cdecimal2) (type: decimal(11,3)), (cdecimal1 - (2 * cdecimal2)) (type: decimal(11,3)), ((cdecimal1 + 2.34) / cdecimal2) (type: decimal(21,11)), (cdecimal1 * (cdecimal2 / 3.4)) (type: decimal(23,9)), (cdecimal1 % 10) (type: decimal(5,3)), UDFToInteger(cdecimal1) (type: int), UDFToShort(cdecimal2) (type: smallint), UDFToByte(cdecimal2) (type: tinyint), UDFToLong(cdecimal1) (type: bigint), UDFToBoolean(cdecimal1) (type: boolean), UDFToDouble(cdecimal2) (type: double), UDFToFloat(cdecimal1) (type: float), CAST( cdecimal2 AS STRING) (type: string), CAST( cdecimal1 AS TIMESTAMP) (type: timestamp) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [7, 10, 13, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36] - selectExpressions: DecimalColAddDecimalColumn(col 5:decimal(10,3), col 6:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 5:decimal(10,3), ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 6:decimal(7,2)) -> 7:decimal(11,3), DecimalColSubtractDecimalColumn(col 8:decimal(10,3), col 37:decimal(9,2))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 8:decimal(10,3), ConvertDecimal64ToDecimal(col 9:decimal(9,2)/DECIMAL_64)(children: Decimal64ScalarMultiplyDecimal64ColumnUnscaled(decimal64Val 2, decimalVal 2, col 2:decimal(7,2)/DECIMAL_64) -> 9:decimal(9,2)/DECIMAL_64) -> 37:decimal(9,2)) -> 10:decimal(11,3), DecimalColDivideDecimalColumn(col 38:decimal(11,3), col 12:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 11:decimal(11,3)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,3)/DECIMAL_64, decimal64Val 2340, decimalVal 2.34) -> 11:decimal(11,3)/DECIMAL_64) -> 38:decimal(11,3), ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 12:decimal(7,2)) -> 13:decimal(21,11), DecimalColMultiplyDecimalColumn(col 14:decimal(10,3), col 39:decimal(12,6))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 14:decimal(10,3), ConvertDecimal64ToDecimal(col 15:decimal(12,6)/DECIMAL_64)(children: Decimal64ColDivideDecimal64Scalar(col 2:decimal(7,2)/DECIMAL_64, decimal64Val 340, decimalVal 3.4) -> 15:decimal(12,6)/DECIMAL_64) -> 39:decimal(12,6)) -> 16:decimal(23,9), DecimalColModuloDecimalScalar(col 17:decimal(10,3), val 10)(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 17:decimal(10,3)) -> 18:decimal(5,3), CastDecimalToLong(col 19:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 19:decimal(10,3)) -> 20:int, CastDecimalToLong(col 21:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 21:decimal(7,2)) -> 22:smallint, CastDecimalToLong(col 23:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 23:decimal(7,2)) -> 24:tinyint, CastDecimalToLong(col 25:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 25:decimal(10,3)) -> 26:bigint, CastDecimalToBoolean(col 27:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 27:decimal(10,3)) -> 28:boolean, CastDecimalToDouble(col 29:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 29:decimal(7,2)) -> 30:double, CastDecimalToFloat(col 31:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 31:decimal(10,3)) -> 32:float, CastDecimalToString(col 33:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 33:decimal(7,2)) -> 34:string, CastDecimalToTimestamp(col 35:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 35:decimal(10,3)) -> 36:timestamp + Top N Key Operator + sort order: ++++++++++++++ + keys: (cdecimal1 + cdecimal2) (type: decimal(11,3)), (cdecimal1 - (2 * cdecimal2)) (type: decimal(11,3)), ((cdecimal1 + 2.34) / cdecimal2) (type: decimal(21,11)), (cdecimal1 * (cdecimal2 / 3.4)) (type: decimal(23,9)), (cdecimal1 % 10) (type: decimal(5,3)), UDFToInteger(cdecimal1) (type: int), UDFToShort(cdecimal2) (type: smallint), UDFToByte(cdecimal2) (type: tinyint), UDFToLong(cdecimal1) (type: bigint), UDFToBoolean(cdecimal1) (type: boolean), UDFToDouble(cdecimal2) (type: double), UDFToFloat(cdecimal1) (type: float), CAST( cdecimal2 AS STRING) (type: string), CAST( cdecimal1 AS TIMESTAMP) (type: timestamp) + null sort order: zzzzzzzzzzzzzz Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: decimal(11,3)), _col1 (type: decimal(11,3)), _col2 (type: decimal(21,11)), _col3 (type: decimal(23,9)), _col4 (type: decimal(5,3)), _col5 (type: int), _col6 (type: smallint), _col7 (type: tinyint), _col8 (type: bigint), _col9 (type: boolean), _col10 (type: double), _col11 (type: float), _col12 (type: string), _col13 (type: timestamp) - null sort order: zzzzzzzzzzzzzz - sort order: ++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 7:decimal(11,3), 10:decimal(11,3), 13:decimal(21,11), 16:decimal(23,9), 18:decimal(5,3), 20:int, 22:smallint, 24:tinyint, 26:bigint, 28:boolean, 30:double, 32:float, 34:string, 36:timestamp + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: DecimalColAddDecimalColumn(col 5:decimal(10,3), col 6:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 5:decimal(10,3), ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 6:decimal(7,2)) -> 7:decimal(11,3), DecimalColSubtractDecimalColumn(col 8:decimal(10,3), col 37:decimal(9,2))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 8:decimal(10,3), ConvertDecimal64ToDecimal(col 9:decimal(9,2)/DECIMAL_64)(children: Decimal64ScalarMultiplyDecimal64ColumnUnscaled(decimal64Val 2, decimalVal 2, col 2:decimal(7,2)/DECIMAL_64) -> 9:decimal(9,2)/DECIMAL_64) -> 37:decimal(9,2)) -> 10:decimal(11,3), DecimalColDivideDecimalColumn(col 38:decimal(11,3), col 12:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 11:decimal(11,3)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,3)/DECIMAL_64, decimal64Val 2340, decimalVal 2.34) -> 11:decimal(11,3)/DECIMAL_64) -> 38:decimal(11,3), ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 12:decimal(7,2)) -> 13:decimal(21,11), DecimalColMultiplyDecimalColumn(col 14:decimal(10,3), col 39:decimal(12,6))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 14:decimal(10,3), ConvertDecimal64ToDecimal(col 15:decimal(12,6)/DECIMAL_64)(children: Decimal64ColDivideDecimal64Scalar(col 2:decimal(7,2)/DECIMAL_64, decimal64Val 340, decimalVal 3.4) -> 15:decimal(12,6)/DECIMAL_64) -> 39:decimal(12,6)) -> 16:decimal(23,9), DecimalColModuloDecimalScalar(col 17:decimal(10,3), val 10)(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 17:decimal(10,3)) -> 18:decimal(5,3), CastDecimalToLong(col 19:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 19:decimal(10,3)) -> 20:int, CastDecimalToLong(col 21:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 21:decimal(7,2)) -> 22:smallint, CastDecimalToLong(col 23:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 23:decimal(7,2)) -> 24:tinyint, CastDecimalToLong(col 25:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 25:decimal(10,3)) -> 26:bigint, CastDecimalToBoolean(col 27:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 27:decimal(10,3)) -> 28:boolean, CastDecimalToDouble(col 29:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 29:decimal(7,2)) -> 30:double, CastDecimalToFloat(col 31:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 31:decimal(10,3)) -> 32:float, CastDecimalToString(col 33:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 33:decimal(7,2)) -> 34:string, CastDecimalToTimestamp(col 35:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 35:decimal(10,3)) -> 36:timestamp + native: true + Select Operator + expressions: (cdecimal1 + cdecimal2) (type: decimal(11,3)), (cdecimal1 - (2 * cdecimal2)) (type: decimal(11,3)), ((cdecimal1 + 2.34) / cdecimal2) (type: decimal(21,11)), (cdecimal1 * (cdecimal2 / 3.4)) (type: decimal(23,9)), (cdecimal1 % 10) (type: decimal(5,3)), UDFToInteger(cdecimal1) (type: int), UDFToShort(cdecimal2) (type: smallint), UDFToByte(cdecimal2) (type: tinyint), UDFToLong(cdecimal1) (type: bigint), UDFToBoolean(cdecimal1) (type: boolean), UDFToDouble(cdecimal2) (type: double), UDFToFloat(cdecimal1) (type: float), CAST( cdecimal2 AS STRING) (type: string), CAST( cdecimal1 AS TIMESTAMP) (type: timestamp) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [41, 43, 46, 48, 49, 50, 52, 54, 55, 56, 58, 59, 61, 62] + selectExpressions: DecimalColAddDecimalColumn(col 4:decimal(10,3), col 40:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3), ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 40:decimal(7,2)) -> 41:decimal(11,3), DecimalColSubtractDecimalColumn(col 4:decimal(10,3), col 63:decimal(9,2))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3), ConvertDecimal64ToDecimal(col 42:decimal(9,2)/DECIMAL_64)(children: Decimal64ScalarMultiplyDecimal64ColumnUnscaled(decimal64Val 2, decimalVal 2, col 2:decimal(7,2)/DECIMAL_64) -> 42:decimal(9,2)/DECIMAL_64) -> 63:decimal(9,2)) -> 43:decimal(11,3), DecimalColDivideDecimalColumn(col 64:decimal(11,3), col 45:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 44:decimal(11,3)/DECIMAL_64)(children: Decimal64ColAddDecimal64Scalar(col 1:decimal(10,3)/DECIMAL_64, decimal64Val 2340, decimalVal 2.34) -> 44:decimal(11,3)/DECIMAL_64) -> 64:decimal(11,3), ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 45:decimal(7,2)) -> 46:decimal(21,11), DecimalColMultiplyDecimalColumn(col 4:decimal(10,3), col 65:decimal(12,6))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3), ConvertDecimal64ToDecimal(col 47:decimal(12,6)/DECIMAL_64)(children: Decimal64ColDivideDecimal64Scalar(col 2:decimal(7,2)/DECIMAL_64, decimal64Val 340, decimalVal 3.4) -> 47:decimal(12,6)/DECIMAL_64) -> 65:decimal(12,6)) -> 48:decimal(23,9), DecimalColModuloDecimalScalar(col 4:decimal(10,3), val 10)(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)) -> 49:decimal(5,3), CastDecimalToLong(col 4:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)) -> 50:int, CastDecimalToLong(col 51:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 51:decimal(7,2)) -> 52:smallint, CastDecimalToLong(col 53:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 53:decimal(7,2)) -> 54:tinyint, CastDecimalToLong(col 4:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)) -> 55:bigint, CastDecimalToBoolean(col 4:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)) -> 56:boolean, CastDecimalToDouble(col 57:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 57:decimal(7,2)) -> 58:double, CastDecimalToFloat(col 4:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)) -> 59:float, CastDecimalToString(col 60:decimal(7,2))(children: ConvertDecimal64ToDecimal(col 2:decimal(7,2)/DECIMAL_64) -> 60:decimal(7,2)) -> 61:string, CastDecimalToTimestamp(col 4:decimal(10,3))(children: ConvertDecimal64ToDecimal(col 1:decimal(10,3)/DECIMAL_64) -> 4:decimal(10,3)) -> 62:timestamp Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: decimal(11,3)), _col1 (type: decimal(11,3)), _col2 (type: decimal(21,11)), _col3 (type: decimal(23,9)), _col4 (type: decimal(5,3)), _col5 (type: int), _col6 (type: smallint), _col7 (type: tinyint), _col8 (type: bigint), _col9 (type: boolean), _col10 (type: double), _col11 (type: float), _col12 (type: string), _col13 (type: timestamp) + null sort order: zzzzzzzzzzzzzz + sort order: ++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 41:decimal(11,3), 43:decimal(11,3), 46:decimal(21,11), 48:decimal(23,9), 49:decimal(5,3), 50:int, 52:smallint, 54:tinyint, 55:bigint, 56:boolean, 58:double, 59:float, 61:string, 62:timestamp + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 1 Data size: 220 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -288,7 +308,7 @@ STAGE PLANS: includeColumns: [0, 1, 2] dataColumns: cdouble:double, cdecimal1:decimal(10,3)/DECIMAL_64, cdecimal2:decimal(7,2)/DECIMAL_64 partitionColumnCount: 0 - scratchColumnTypeNames: [decimal(10,3), decimal(10,3), decimal(7,2), decimal(11,3), decimal(10,3), decimal(9,2)/DECIMAL_64, decimal(11,3), decimal(11,3)/DECIMAL_64, decimal(7,2), decimal(21,11), decimal(10,3), decimal(12,6)/DECIMAL_64, decimal(23,9), decimal(10,3), decimal(5,3), decimal(10,3), bigint, decimal(7,2), bigint, decimal(7,2), bigint, decimal(10,3), bigint, decimal(10,3), bigint, decimal(7,2), double, decimal(10,3), double, decimal(7,2), string, decimal(10,3), timestamp, decimal(9,2), decimal(11,3), decimal(12,6)] + scratchColumnTypeNames: [decimal(10,3), decimal(10,3), decimal(7,2), decimal(11,3), decimal(10,3), decimal(9,2)/DECIMAL_64, decimal(11,3), decimal(11,3)/DECIMAL_64, decimal(7,2), decimal(21,11), decimal(10,3), decimal(12,6)/DECIMAL_64, decimal(23,9), decimal(10,3), decimal(5,3), decimal(10,3), bigint, decimal(7,2), bigint, decimal(7,2), bigint, decimal(10,3), bigint, decimal(10,3), bigint, decimal(7,2), double, decimal(10,3), double, decimal(7,2), string, decimal(10,3), timestamp, decimal(9,2), decimal(11,3), decimal(12,6), decimal(7,2), decimal(11,3), decimal(9,2)/DECIMAL_64, decimal(11,3), decimal(11,3)/DECIMAL_64, decimal(7,2), decimal(21,11), decimal(12,6)/DECIMAL_64, decimal(23,9), decimal(5,3), bigint, decimal(7,2), bigint, decimal(7,2), bigint, bigint, bigint, decimal(7,2), double, double, decimal(7,2), string, timestamp, decimal(9,2), decimal(11,3), decimal(12,6)] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_groupby_grouping_sets_limit.q.out ql/src/test/results/clientpositive/llap/vector_groupby_grouping_sets_limit.q.out index 6fd15e7101..c7e837905d 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby_grouping_sets_limit.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby_grouping_sets_limit.q.out @@ -72,31 +72,31 @@ STAGE PLANS: native: true projectedOutputColumnNums: [0, 1] Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: +++ - keys: a (type: string), b (type: string), 0L (type: bigint) - null sort order: zza - Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator + Group By Operator + aggregations: count() + Group By Vectorization: + aggregators: VectorUDAFCountStar(*) -> bigint + className: VectorGroupByOperator + groupByMode: HASH keyExpressions: col 0:string, col 1:string, ConstantVectorExpression(val 0) -> 4:bigint - native: true - Group By Operator - aggregations: count() - Group By Vectorization: - aggregators: VectorUDAFCountStar(*) -> bigint - className: VectorGroupByOperator - groupByMode: HASH - keyExpressions: col 0:string, col 1:string, ConstantVectorExpression(val 0) -> 5:bigint - native: false - vectorProcessingMode: HASH - projectedOutputColumnNums: [0] - keys: a (type: string), b (type: string), 0L (type: bigint) - minReductionHashAggr: 0.0 - mode: hash - outputColumnNames: _col0, _col1, _col2, _col3 + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + keys: a (type: string), b (type: string), 0L (type: bigint) + minReductionHashAggr: 0.0 + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 12 Data size: 2232 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 12 Data size: 2232 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:string, col 1:string + native: true Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) null sort order: zza @@ -127,7 +127,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: a:string, b:string, c:string partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, bigint] + scratchColumnTypeNames: [bigint] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -290,31 +290,31 @@ STAGE PLANS: native: true projectedOutputColumnNums: [0, 1] Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: +++ - keys: a (type: string), b (type: string), 0L (type: bigint) - null sort order: zza - Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator + Group By Operator + aggregations: count() + Group By Vectorization: + aggregators: VectorUDAFCountStar(*) -> bigint + className: VectorGroupByOperator + groupByMode: HASH keyExpressions: col 0:string, col 1:string, ConstantVectorExpression(val 0) -> 4:bigint - native: true - Group By Operator - aggregations: count() - Group By Vectorization: - aggregators: VectorUDAFCountStar(*) -> bigint - className: VectorGroupByOperator - groupByMode: HASH - keyExpressions: col 0:string, col 1:string, ConstantVectorExpression(val 0) -> 5:bigint - native: false - vectorProcessingMode: HASH - projectedOutputColumnNums: [0] - keys: a (type: string), b (type: string), 0L (type: bigint) - minReductionHashAggr: 0.0 - mode: hash - outputColumnNames: _col0, _col1, _col2, _col3 + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + keys: a (type: string), b (type: string), 0L (type: bigint) + minReductionHashAggr: 0.0 + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 12 Data size: 2232 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 12 Data size: 2232 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:string, col 1:string + native: true Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) null sort order: zza @@ -345,7 +345,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: a:string, b:string, c:string partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, bigint] + scratchColumnTypeNames: [bigint] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -508,31 +508,31 @@ STAGE PLANS: native: true projectedOutputColumnNums: [0, 1] Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: +++ - keys: a (type: string), b (type: string), 0L (type: bigint) - null sort order: zza - Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator + Group By Operator + aggregations: count() + Group By Vectorization: + aggregators: VectorUDAFCountStar(*) -> bigint + className: VectorGroupByOperator + groupByMode: HASH keyExpressions: col 0:string, col 1:string, ConstantVectorExpression(val 0) -> 4:bigint - native: true - Group By Operator - aggregations: count() - Group By Vectorization: - aggregators: VectorUDAFCountStar(*) -> bigint - className: VectorGroupByOperator - groupByMode: HASH - keyExpressions: col 0:string, col 1:string, ConstantVectorExpression(val 0) -> 5:bigint - native: false - vectorProcessingMode: HASH - projectedOutputColumnNums: [0] - keys: a (type: string), b (type: string), 0L (type: bigint) - minReductionHashAggr: 0.0 - mode: hash - outputColumnNames: _col0, _col1, _col2, _col3 + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [0] + keys: a (type: string), b (type: string), 0L (type: bigint) + minReductionHashAggr: 0.0 + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 6 Data size: 1116 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: _col0 (type: string), _col1 (type: string) + null sort order: zz Statistics: Num rows: 6 Data size: 1116 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:string, col 1:string + native: true Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint) null sort order: zza @@ -563,7 +563,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: a:string, b:string, c:string partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, bigint] + scratchColumnTypeNames: [bigint] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -726,29 +726,29 @@ STAGE PLANS: native: true projectedOutputColumnNums: [0, 1, 2] Statistics: Num rows: 6 Data size: 1530 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: ++++ - keys: a (type: string), b (type: string), c (type: string), 0L (type: bigint) - null sort order: zaaa - Statistics: Num rows: 6 Data size: 1530 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator + Group By Operator + Group By Vectorization: + className: VectorGroupByOperator + groupByMode: HASH keyExpressions: col 0:string, col 1:string, col 2:string, ConstantVectorExpression(val 0) -> 4:bigint - native: true - Group By Operator - Group By Vectorization: - className: VectorGroupByOperator - groupByMode: HASH - keyExpressions: col 0:string, col 1:string, col 2:string, ConstantVectorExpression(val 0) -> 5:bigint - native: false - vectorProcessingMode: HASH - projectedOutputColumnNums: [] - keys: a (type: string), b (type: string), c (type: string), 0L (type: bigint) - minReductionHashAggr: 0.0 - mode: hash - outputColumnNames: _col0, _col1, _col2, _col3 + native: false + vectorProcessingMode: HASH + projectedOutputColumnNums: [] + keys: a (type: string), b (type: string), c (type: string), 0L (type: bigint) + minReductionHashAggr: 0.0 + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 9 Data size: 2367 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: + + keys: _col0 (type: string) + null sort order: z Statistics: Num rows: 9 Data size: 2367 Basic stats: COMPLETE Column stats: COMPLETE + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:string + native: true Reduce Output Operator key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: string), _col3 (type: bigint) null sort order: zaaa @@ -777,7 +777,7 @@ STAGE PLANS: includeColumns: [0, 1, 2] dataColumns: a:string, b:string, c:string partitionColumnCount: 0 - scratchColumnTypeNames: [bigint, bigint] + scratchColumnTypeNames: [bigint] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -928,24 +928,24 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:a:string, 1:b:string, 2:c:string, 3:ROW__ID:struct] - Select Operator - expressions: a (type: string) - outputColumnNames: a - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0] + Top N Key Operator + sort order: + + keys: a (type: string) + null sort order: z Statistics: Num rows: 6 Data size: 510 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: a (type: string) - null sort order: z - Statistics: Num rows: 6 Data size: 510 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 0:string + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:string + native: true + Select Operator + expressions: a (type: string) + outputColumnNames: a + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [0] + Statistics: Num rows: 6 Data size: 510 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator Group By Vectorization: className: VectorGroupByOperator @@ -1124,32 +1124,32 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:a:string, 1:b:string, 2:c:string, 3:ROW__ID:struct] - Select Operator - expressions: (UDFToDouble(a) + UDFToDouble(b)) (type: double) - outputColumnNames: _col0 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [6] - selectExpressions: DoubleColAddDoubleColumn(col 4:double, col 5:double)(children: CastStringToDouble(col 0:string) -> 4:double, CastStringToDouble(col 1:string) -> 5:double) -> 6:double + Top N Key Operator + sort order: + + keys: (UDFToDouble(a) + UDFToDouble(b)) (type: double) + null sort order: z Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: double) - null sort order: z - Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE - top n: 10 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 6:double + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: DoubleColAddDoubleColumn(col 4:double, col 5:double)(children: CastStringToDouble(col 0:string) -> 4:double, CastStringToDouble(col 1:string) -> 5:double) -> 6:double + native: true + Select Operator + expressions: (UDFToDouble(a) + UDFToDouble(b)) (type: double) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [9] + selectExpressions: DoubleColAddDoubleColumn(col 7:double, col 8:double)(children: CastStringToDouble(col 0:string) -> 7:double, CastStringToDouble(col 1:string) -> 8:double) -> 9:double + Statistics: Num rows: 6 Data size: 1020 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator aggregations: count() Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 6:double + keyExpressions: col 9:double native: false vectorProcessingMode: HASH projectedOutputColumnNums: [0] @@ -1188,7 +1188,7 @@ STAGE PLANS: includeColumns: [0, 1] dataColumns: a:string, b:string, c:string partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, double] + scratchColumnTypeNames: [double, double, double, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out index d6325982e3..96bb9ee03b 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out @@ -262,24 +262,24 @@ STAGE PLANS: Statistics: Num rows: 1000 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: ss_ticket_number (type: int) - outputColumnNames: ss_ticket_number - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [9] + Top N Key Operator + sort order: + + keys: ss_ticket_number (type: int) + null sort order: z Statistics: Num rows: 1000 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: ss_ticket_number (type: int) - null sort order: z - Statistics: Num rows: 1000 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 9:int + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 9:int + native: true + Select Operator + expressions: ss_ticket_number (type: int) + outputColumnNames: ss_ticket_number + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [9] + Statistics: Num rows: 1000 Data size: 4000 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator Group By Vectorization: className: VectorGroupByOperator diff --git ql/src/test/results/clientpositive/llap/vector_identity_reuse.q.out ql/src/test/results/clientpositive/llap/vector_identity_reuse.q.out index 00aa4fbf7d..9264a347b8 100644 --- ql/src/test/results/clientpositive/llap/vector_identity_reuse.q.out +++ ql/src/test/results/clientpositive/llap/vector_identity_reuse.q.out @@ -65,7 +65,7 @@ POSTHOOK: Output: default@u_table_19 POSTHOOK: Lineage: u_table_19.bigint_col_18 SCRIPT [] POSTHOOK: Lineage: u_table_19.int_col_19 SCRIPT [] POSTHOOK: Lineage: u_table_19.string_col_7 SCRIPT [] -Warning: Map Join MAPJOIN[28][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[29][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: explain vectorization detail SELECT a5.int_col, @@ -227,28 +227,38 @@ STAGE PLANS: input vertices: 1 Map 4 Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: int), CASE WHEN (_col0 is not null) THEN (_col0) ELSE (UDFToInteger(_col1)) END (type: int), _col2 (type: int) - outputColumnNames: _col0, _col1, _col2 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [4, 8, 6] - selectExpressions: IfExprColumnCondExpr(col 7:boolean, col 4:intcol 5:smallint)(children: IsNotNull(col 4:int) -> 7:boolean, col 4:int, col 5:smallint) -> 8:int + Top N Key Operator + sort order: - + keys: _col0 (type: int) + null sort order: z Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: - - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 4:int + top n: 100 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 4:int + native: true + Select Operator + expressions: _col0 (type: int), CASE WHEN (_col0 is not null) THEN (_col0) ELSE (UDFToInteger(_col1)) END (type: int), _col2 (type: int) + outputColumnNames: _col0, _col1, _col2 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - valueColumns: 8:int, 6:int + projectedOutputColumnNums: [4, 8, 6] + selectExpressions: IfExprColumnCondExpr(col 7:boolean, col 4:intcol 5:smallint)(children: IsNotNull(col 4:int) -> 7:boolean, col 4:int, col 5:smallint) -> 8:int Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: int), _col2 (type: int) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: - + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 4:int + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + valueColumns: 8:int, 6:int + Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: int), _col2 (type: int) Execution mode: vectorized, llap LLAP IO: no inputs Map Vectorization: @@ -424,7 +434,7 @@ STAGE PLANS: Processor Tree: ListSink -Warning: Map Join MAPJOIN[28][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[29][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: SELECT a5.int_col, 922 as expected, diff --git ql/src/test/results/clientpositive/llap/vector_llap_text_1.q.out ql/src/test/results/clientpositive/llap/vector_llap_text_1.q.out index 1f7ed5a129..da8673add9 100644 --- ql/src/test/results/clientpositive/llap/vector_llap_text_1.q.out +++ ql/src/test/results/clientpositive/llap/vector_llap_text_1.q.out @@ -248,25 +248,35 @@ STAGE PLANS: input vertices: 0 Map 1 Statistics: Num rows: 399 Data size: 74214 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: int), _col1 (type: string), _col3 (type: string) - outputColumnNames: _col0, _col1, _col2 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 4, 1] + Top N Key Operator + sort order: +++ + keys: _col0 (type: int), _col1 (type: string), _col3 (type: string) + null sort order: zzz Statistics: Num rows: 399 Data size: 74214 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string) - null sort order: zzz - sort order: +++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:int, 4:string, 1:string + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 4:string, col 1:string + native: true + Select Operator + expressions: _col0 (type: int), _col1 (type: string), _col3 (type: string) + outputColumnNames: _col0, _col1, _col2 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 4, 1] Statistics: Num rows: 399 Data size: 74214 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string) + null sort order: zzz + sort order: +++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:int, 4:string, 1:string + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 399 Data size: 74214 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: no inputs Map Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out index 48e840584e..27b70feee0 100644 --- ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out +++ ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out @@ -278,25 +278,35 @@ STAGE PLANS: Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] + Top N Key Operator + sort order: ++ + keys: fl_num (type: int), fl_date (type: date) + null sort order: zz Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col5 (type: int), _col2 (type: date) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 5:int, col 2:date + native: true + Select Operator + expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) + Reduce Output Operator + key expressions: _col5 (type: int), _col2 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -331,17 +341,27 @@ STAGE PLANS: className: VectorLimitOperator native: true Statistics: Num rows: 25 Data size: 7200 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col5 (type: int), _col2 (type: date) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col5 (type: int), _col2 (type: date) + null sort order: zz Statistics: Num rows: 25 Data size: 7200 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:date + native: true + Reduce Output Operator + key expressions: _col5 (type: int), _col2 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 25 Data size: 7200 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -1249,25 +1269,35 @@ STAGE PLANS: Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: origin_city_name (type: string), dest_city_name (type: string), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int), fl_date (type: date) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] + Top N Key Operator + sort order: ++ + keys: fl_num (type: int), fl_date (type: date) + null sort order: zz Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: date) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 4:int, col 5:date + native: true + Select Operator + expressions: origin_city_name (type: string), dest_city_name (type: string), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int), fl_date (type: date) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -1302,17 +1332,27 @@ STAGE PLANS: className: VectorLimitOperator native: true Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: date) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col4 (type: int), _col5 (type: date) + null sort order: zz Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:date + native: true + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -2292,25 +2332,35 @@ STAGE PLANS: Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), arr_delay (type: float), fl_num (type: int), fl_time (type: timestamp) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] + Top N Key Operator + sort order: ++ + keys: fl_num (type: int), fl_time (type: timestamp) + null sort order: zz Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: timestamp) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 4:int, col 5:timestamp + native: true + Select Operator + expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), arr_delay (type: float), fl_num (type: int), fl_time (type: timestamp) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: timestamp) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -2345,17 +2395,27 @@ STAGE PLANS: className: VectorLimitOperator native: true Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: timestamp) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col4 (type: int), _col5 (type: timestamp) + null sort order: zz Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:timestamp + native: true + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: timestamp) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -2891,25 +2951,35 @@ STAGE PLANS: Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] + Top N Key Operator + sort order: ++ + keys: fl_num (type: int), fl_date (type: date) + null sort order: zz Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col5 (type: int), _col2 (type: date) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 5:int, col 2:date + native: true + Select Operator + expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) + Reduce Output Operator + key expressions: _col5 (type: int), _col2 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 137 Data size: 39456 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs (cache only) Map Vectorization: @@ -2944,17 +3014,27 @@ STAGE PLANS: className: VectorLimitOperator native: true Statistics: Num rows: 25 Data size: 7200 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col5 (type: int), _col2 (type: date) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col5 (type: int), _col2 (type: date) + null sort order: zz Statistics: Num rows: 25 Data size: 7200 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:date + native: true + Reduce Output Operator + key expressions: _col5 (type: int), _col2 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 25 Data size: 7200 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col3 (type: timestamp), _col4 (type: float) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -3862,25 +3942,35 @@ STAGE PLANS: Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: origin_city_name (type: string), dest_city_name (type: string), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int), fl_date (type: date) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] + Top N Key Operator + sort order: ++ + keys: fl_num (type: int), fl_date (type: date) + null sort order: zz Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: date) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 4:int, col 5:date + native: true + Select Operator + expressions: origin_city_name (type: string), dest_city_name (type: string), fl_time (type: timestamp), arr_delay (type: float), fl_num (type: int), fl_date (type: date) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs (cache only) Map Vectorization: @@ -3915,17 +4005,27 @@ STAGE PLANS: className: VectorLimitOperator native: true Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: date) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col4 (type: int), _col5 (type: date) + null sort order: zz Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:date + native: true + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: date) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: timestamp), _col3 (type: float) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -4905,25 +5005,35 @@ STAGE PLANS: Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), arr_delay (type: float), fl_num (type: int), fl_time (type: timestamp) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] + Top N Key Operator + sort order: ++ + keys: fl_num (type: int), fl_time (type: timestamp) + null sort order: zz Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: timestamp) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 4:int, col 5:timestamp + native: true + Select Operator + expressions: origin_city_name (type: string), dest_city_name (type: string), fl_date (type: date), arr_delay (type: float), fl_num (type: int), fl_time (type: timestamp) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5] Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: timestamp) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 137 Data size: 39593 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) Execution mode: vectorized, llap LLAP IO: all inputs (cache only) Map Vectorization: @@ -4958,17 +5068,27 @@ STAGE PLANS: className: VectorLimitOperator native: true Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col4 (type: int), _col5 (type: timestamp) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col4 (type: int), _col5 (type: timestamp) + null sort order: zz Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:timestamp + native: true + Reduce Output Operator + key expressions: _col4 (type: int), _col5 (type: timestamp) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 25 Data size: 7225 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: string), _col1 (type: string), _col2 (type: date), _col3 (type: float) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: diff --git ql/src/test/results/clientpositive/llap/vector_string_concat.q.out ql/src/test/results/clientpositive/llap/vector_string_concat.q.out index a8019be7aa..beb02579ea 100644 --- ql/src/test/results/clientpositive/llap/vector_string_concat.q.out +++ ql/src/test/results/clientpositive/llap/vector_string_concat.q.out @@ -351,30 +351,30 @@ STAGE PLANS: Statistics: Num rows: 2000 Data size: 106288 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: concat(concat(concat('Quarter ', CAST( UDFToInteger(((UDFToDouble((month(dt) - 1)) / 3.0D) + 1.0D)) AS STRING)), '-'), CAST( year(dt) AS STRING)) (type: string) - outputColumnNames: _col0 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [25] - selectExpressions: StringGroupConcatColCol(col 22:string, col 24:string)(children: StringGroupColConcatStringScalar(col 21:string, val -)(children: StringScalarConcatStringGroupCol(val Quarter , col 20:string)(children: CastLongToString(col 19:int)(children: CastDoubleToLong(col 18:double)(children: DoubleColAddDoubleScalar(col 17:double, val 1.0)(children: DoubleColDivideDoubleScalar(col 16:double, val 3.0)(children: CastLongToDouble(col 15:int)(children: LongColSubtractLongScalar(col 14:int, val 1)(children: VectorUDFMonthDate(col 12, field MONTH) -> 14:int) -> 15:int) -> 16:double) -> 17:double) -> 18:double) -> 19:int) -> 20:string) -> 21:string) -> 22:string, CastLongToString(col 23:int)(children: VectorUDFYearDate(col 12, field YEAR) -> 23:int) -> 24:string) -> 25:string + Top N Key Operator + sort order: + + keys: concat(concat(concat('Quarter ', CAST( UDFToInteger(((UDFToDouble((month(dt) - 1)) / 3.0D) + 1.0D)) AS STRING)), '-'), CAST( year(dt) AS STRING)) (type: string) + null sort order: z Statistics: Num rows: 2000 Data size: 106288 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z - Statistics: Num rows: 2000 Data size: 106288 Basic stats: COMPLETE Column stats: COMPLETE - top n: 50 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 25:string + top n: 50 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: StringGroupConcatColCol(col 22:string, col 24:string)(children: StringGroupColConcatStringScalar(col 21:string, val -)(children: StringScalarConcatStringGroupCol(val Quarter , col 20:string)(children: CastLongToString(col 19:int)(children: CastDoubleToLong(col 18:double)(children: DoubleColAddDoubleScalar(col 17:double, val 1.0)(children: DoubleColDivideDoubleScalar(col 16:double, val 3.0)(children: CastLongToDouble(col 15:int)(children: LongColSubtractLongScalar(col 14:int, val 1)(children: VectorUDFMonthDate(col 12, field MONTH) -> 14:int) -> 15:int) -> 16:double) -> 17:double) -> 18:double) -> 19:int) -> 20:string) -> 21:string) -> 22:string, CastLongToString(col 23:int)(children: VectorUDFYearDate(col 12, field YEAR) -> 23:int) -> 24:string) -> 25:string + native: true + Select Operator + expressions: concat(concat(concat('Quarter ', CAST( UDFToInteger(((UDFToDouble((month(dt) - 1)) / 3.0D) + 1.0D)) AS STRING)), '-'), CAST( year(dt) AS STRING)) (type: string) + outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [37] + selectExpressions: StringGroupConcatColCol(col 34:string, col 36:string)(children: StringGroupColConcatStringScalar(col 33:string, val -)(children: StringScalarConcatStringGroupCol(val Quarter , col 32:string)(children: CastLongToString(col 31:int)(children: CastDoubleToLong(col 30:double)(children: DoubleColAddDoubleScalar(col 29:double, val 1.0)(children: DoubleColDivideDoubleScalar(col 28:double, val 3.0)(children: CastLongToDouble(col 27:int)(children: LongColSubtractLongScalar(col 26:int, val 1)(children: VectorUDFMonthDate(col 12, field MONTH) -> 26:int) -> 27:int) -> 28:double) -> 29:double) -> 30:double) -> 31:int) -> 32:string) -> 33:string) -> 34:string, CastLongToString(col 35:int)(children: VectorUDFYearDate(col 12, field YEAR) -> 35:int) -> 36:string) -> 37:string + Statistics: Num rows: 2000 Data size: 106288 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator Group By Vectorization: className: VectorGroupByOperator groupByMode: HASH - keyExpressions: col 25:string + keyExpressions: col 37:string native: false vectorProcessingMode: HASH projectedOutputColumnNums: [] diff --git ql/src/test/results/clientpositive/llap/vector_topnkey.q.out ql/src/test/results/clientpositive/llap/vector_topnkey.q.out index c140bdfd37..9e382c051f 100644 --- ql/src/test/results/clientpositive/llap/vector_topnkey.q.out +++ ql/src/test/results/clientpositive/llap/vector_topnkey.q.out @@ -87,24 +87,24 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:cint1:int, 1:cint2:int, 2:cdouble:double, 3:cvarchar:varchar(50), 4:cdecimal1:decimal(10,2)/DECIMAL_64, 5:cdecimal2:decimal(38,5), 6:ROW__ID:struct] - Select Operator - expressions: cint1 (type: int) - outputColumnNames: cint1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0] + Top N Key Operator + sort order: + + keys: cint1 (type: int) + null sort order: z Statistics: Num rows: 14 Data size: 44 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: cint1 (type: int) - null sort order: z - Statistics: Num rows: 14 Data size: 44 Basic stats: COMPLETE Column stats: COMPLETE - top n: 3 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 0:int + top n: 3 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: cint1 (type: int) + outputColumnNames: cint1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [0] + Statistics: Num rows: 14 Data size: 44 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator Group By Vectorization: className: VectorGroupByOperator diff --git ql/src/test/results/clientpositive/llap/vector_varchar_simple.q.out ql/src/test/results/clientpositive/llap/vector_varchar_simple.q.out index 6bb2fbde0c..382f6d14de 100644 --- ql/src/test/results/clientpositive/llap/vector_varchar_simple.q.out +++ ql/src/test/results/clientpositive/llap/vector_varchar_simple.q.out @@ -80,17 +80,23 @@ STAGE PLANS: TableScan alias: varchar_2_n0 Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: varchar(10)), value (type: varchar(20)) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: key (type: varchar(10)) + null sort order: z Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: varchar(10)) - null sort order: z - sort order: + + top n: 5 + Select Operator + expressions: key (type: varchar(10)), value (type: varchar(20)) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: varchar(20)) + Reduce Output Operator + key expressions: _col0 (type: varchar(10)) + null sort order: z + sort order: + + Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: varchar(20)) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -205,17 +211,23 @@ STAGE PLANS: TableScan alias: varchar_2_n0 Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: key (type: varchar(10)), value (type: varchar(20)) - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: - + keys: key (type: varchar(10)) + null sort order: z Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: varchar(10)) - null sort order: z - sort order: - + top n: 5 + Select Operator + expressions: key (type: varchar(10)), value (type: varchar(20)) + outputColumnNames: _col0, _col1 Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: varchar(20)) + Reduce Output Operator + key expressions: _col0 (type: varchar(10)) + null sort order: z + sort order: - + Statistics: Num rows: 500 Data size: 94248 Basic stats: COMPLETE Column stats: NONE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: varchar(20)) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: diff --git ql/src/test/results/clientpositive/llap/vectorization_13.q.out ql/src/test/results/clientpositive/llap/vectorization_13.q.out index 3f9f1b7770..72bac2d64d 100644 --- ql/src/test/results/clientpositive/llap/vectorization_13.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_13.q.out @@ -171,40 +171,60 @@ STAGE PLANS: partitionColumnCount: 0 scratchColumnTypeNames: [] Reduce Operator Tree: - Group By Operator - aggregations: max(VALUE._col0), sum(VALUE._col1), sum(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6), count(VALUE._col7), max(VALUE._col8), min(VALUE._col9) - Group By Vectorization: - aggregators: VectorUDAFMaxLong(col 5:tinyint) -> tinyint, VectorUDAFSumDouble(col 6:double) -> double, VectorUDAFSumDouble(col 7:double) -> double, VectorUDAFSumDouble(col 8:double) -> double, VectorUDAFCountMerge(col 9:bigint) -> bigint, VectorUDAFSumDouble(col 10:double) -> double, VectorUDAFSumDouble(col 11:double) -> double, VectorUDAFCountMerge(col 12:bigint) -> bigint, VectorUDAFMaxDouble(col 13:float) -> float, VectorUDAFMinLong(col 14:tinyint) -> tinyint - className: VectorGroupByOperator - groupByMode: MERGEPARTIAL - keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string - native: false - vectorProcessingMode: MERGE_PARTIAL - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Top N Key Operator + sort order: +++++ keys: KEY._col0 (type: boolean), KEY._col1 (type: tinyint), KEY._col2 (type: timestamp), KEY._col3 (type: float), KEY._col4 (type: string) - mode: mergepartial - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + null sort order: zzzzz Statistics: Num rows: 693 Data size: 122752 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), (- _col1) (type: tinyint), _col5 (type: tinyint), ((- _col1) + _col5) (type: tinyint), _col6 (type: double), (_col6 * UDFToDouble(((- _col1) + _col5))) (type: double), (- _col6) (type: double), (79.553 * _col3) (type: float), power(((_col7 - ((_col8 * _col8) / _col9)) / _col9), 0.5) (type: double), (- _col6) (type: double), power(((_col10 - ((_col11 * _col11) / _col12)) / _col12), 0.5) (type: double), (CAST( ((- _col1) + _col5) AS decimal(3,0)) - 10.175) (type: decimal(7,3)), (- (- _col6)) (type: double), (-26.28D / (- (- _col6))) (type: double), _col13 (type: float), ((_col6 * UDFToDouble(((- _col1) + _col5))) / UDFToDouble(_col1)) (type: double), _col14 (type: tinyint) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 15, 5, 17, 6, 21, 22, 23, 28, 29, 34, 38, 40, 43, 13, 49, 14] - selectExpressions: LongColUnaryMinus(col 1:tinyint) -> 15:tinyint, LongColAddLongColumn(col 16:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 16:tinyint) -> 17:tinyint, DoubleColMultiplyDoubleColumn(col 6:double, col 20:double)(children: CastLongToDouble(col 19:tinyint)(children: LongColAddLongColumn(col 18:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 18:tinyint) -> 19:tinyint) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 6:double) -> 22:double, DoubleScalarMultiplyDoubleColumn(val 79.5530014038086, col 3:float) -> 23:float, FuncPowerDoubleToDouble(col 27:double)(children: DoubleColDivideLongColumn(col 26:double, col 9:bigint)(children: DoubleColSubtractDoubleColumn(col 7:double, col 25:double)(children: DoubleColDivideLongColumn(col 24:double, col 9:bigint)(children: DoubleColMultiplyDoubleColumn(col 8:double, col 8:double) -> 24:double) -> 25:double) -> 26:double) -> 27:double) -> 28:double, DoubleColUnaryMinus(col 6:double) -> 29:double, FuncPowerDoubleToDouble(col 33:double)(children: DoubleColDivideLongColumn(col 32:double, col 12:bigint)(children: DoubleColSubtractDoubleColumn(col 10:double, col 31:double)(children: DoubleColDivideLongColumn(col 30:double, col 12:bigint)(children: DoubleColMultiplyDoubleColumn(col 11:double, col 11:double) -> 30:double) -> 31:double) -> 32:double) -> 33:double) -> 34:double, DecimalColSubtractDecimalScalar(col 37:decimal(3,0), val 10.175)(children: CastLongToDecimal(col 36:tinyint)(children: LongColAddLongColumn(col 35:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 35:tinyint) -> 36:tinyint) -> 37:decimal(3,0)) -> 38:decimal(7,3), DoubleColUnaryMinus(col 39:double)(children: DoubleColUnaryMinus(col 6:double) -> 39:double) -> 40:double, DoubleScalarDivideDoubleColumn(val -26.28, col 42:double)(children: DoubleColUnaryMinus(col 41:double)(children: DoubleColUnaryMinus(col 6:double) -> 41:double) -> 42:double) -> 43:double, DoubleColDivideDoubleColumn(col 47:double, col 48:double)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 46:double)(children: CastLongToDouble(col 45:tinyint)(children: LongColAddLongColumn(col 44:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 44:tinyint) -> 45:tinyint) -> 46:double) -> 47:double, CastLongToDouble(col 1:tinyint) -> 48:double) -> 49:double - Statistics: Num rows: 693 Data size: 219772 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), _col5 (type: tinyint), _col6 (type: tinyint), _col7 (type: tinyint), _col8 (type: double), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: decimal(7,3)), _col16 (type: double), _col17 (type: double), _col18 (type: float), _col19 (type: double), _col20 (type: tinyint) - null sort order: zzzzzzzzzzzzzzzzzzzzz + top n: 40 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string + native: true + Group By Operator + aggregations: max(VALUE._col0), sum(VALUE._col1), sum(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6), count(VALUE._col7), max(VALUE._col8), min(VALUE._col9) + Group By Vectorization: + aggregators: VectorUDAFMaxLong(col 5:tinyint) -> tinyint, VectorUDAFSumDouble(col 6:double) -> double, VectorUDAFSumDouble(col 7:double) -> double, VectorUDAFSumDouble(col 8:double) -> double, VectorUDAFCountMerge(col 9:bigint) -> bigint, VectorUDAFSumDouble(col 10:double) -> double, VectorUDAFSumDouble(col 11:double) -> double, VectorUDAFCountMerge(col 12:bigint) -> bigint, VectorUDAFMaxDouble(col 13:float) -> float, VectorUDAFMinLong(col 14:tinyint) -> tinyint + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string + native: false + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + keys: KEY._col0 (type: boolean), KEY._col1 (type: tinyint), KEY._col2 (type: timestamp), KEY._col3 (type: float), KEY._col4 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + Statistics: Num rows: 693 Data size: 97056 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator sort order: +++++++++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:boolean, 1:tinyint, 2:timestamp, 3:float, 4:string, 15:tinyint, 5:tinyint, 17:tinyint, 6:double, 21:double, 22:double, 23:float, 28:double, 29:double, 34:double, 38:decimal(7,3), 40:double, 43:double, 13:float, 49:double, 14:tinyint + keys: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), (- _col1) (type: tinyint), _col5 (type: tinyint), ((- _col1) + _col5) (type: tinyint), _col6 (type: double), (_col6 * UDFToDouble(((- _col1) + _col5))) (type: double), (- _col6) (type: double), (79.553 * _col3) (type: float), power(((_col7 - ((_col8 * _col8) / _col9)) / _col9), 0.5) (type: double), (- _col6) (type: double), power(((_col10 - ((_col11 * _col11) / _col12)) / _col12), 0.5) (type: double), (CAST( ((- _col1) + _col5) AS decimal(3,0)) - 10.175) (type: decimal(7,3)), (- (- _col6)) (type: double), (-26.28D / (- (- _col6))) (type: double), _col13 (type: float), ((_col6 * UDFToDouble(((- _col1) + _col5))) / UDFToDouble(_col1)) (type: double), _col14 (type: tinyint) + null sort order: zzzzzzzzzzzzzzzzzzzzz + Statistics: Num rows: 693 Data size: 97056 Basic stats: COMPLETE Column stats: COMPLETE + top n: 40 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string, LongColUnaryMinus(col 1:tinyint) -> 15:tinyint, col 5:tinyint, LongColAddLongColumn(col 16:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 16:tinyint) -> 17:tinyint, col 6:double, DoubleColMultiplyDoubleColumn(col 6:double, col 20:double)(children: CastLongToDouble(col 19:tinyint)(children: LongColAddLongColumn(col 18:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 18:tinyint) -> 19:tinyint) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 6:double) -> 22:double, DoubleScalarMultiplyDoubleColumn(val 79.5530014038086, col 3:float) -> 23:float, FuncPowerDoubleToDouble(col 27:double)(children: DoubleColDivideLongColumn(col 26:double, col 9:bigint)(children: DoubleColSubtractDoubleColumn(col 7:double, col 25:double)(children: DoubleColDivideLongColumn(col 24:double, col 9:bigint)(children: DoubleColMultiplyDoubleColumn(col 8:double, col 8:double) -> 24:double) -> 25:double) -> 26:double) -> 27:double) -> 28:double, DoubleColUnaryMinus(col 6:double) -> 29:double, FuncPowerDoubleToDouble(col 33:double)(children: DoubleColDivideLongColumn(col 32:double, col 12:bigint)(children: DoubleColSubtractDoubleColumn(col 10:double, col 31:double)(children: DoubleColDivideLongColumn(col 30:double, col 12:bigint)(children: DoubleColMultiplyDoubleColumn(col 11:double, col 11:double) -> 30:double) -> 31:double) -> 32:double) -> 33:double) -> 34:double, DecimalColSubtractDecimalScalar(col 37:decimal(3,0), val 10.175)(children: CastLongToDecimal(col 36:tinyint)(children: LongColAddLongColumn(col 35:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 35:tinyint) -> 36:tinyint) -> 37:decimal(3,0)) -> 38:decimal(7,3), DoubleColUnaryMinus(col 39:double)(children: DoubleColUnaryMinus(col 6:double) -> 39:double) -> 40:double, DoubleScalarDivideDoubleColumn(val -26.28, col 42:double)(children: DoubleColUnaryMinus(col 41:double)(children: DoubleColUnaryMinus(col 6:double) -> 41:double) -> 42:double) -> 43:double, col 13:float, DoubleColDivideDoubleColumn(col 47:double, col 48:double)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 46:double)(children: CastLongToDouble(col 45:tinyint)(children: LongColAddLongColumn(col 44:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 44:tinyint) -> 45:tinyint) -> 46:double) -> 47:double, CastLongToDouble(col 1:tinyint) -> 48:double) -> 49:double, col 14:tinyint native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 693 Data size: 219772 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Select Operator + expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), (- _col1) (type: tinyint), _col5 (type: tinyint), ((- _col1) + _col5) (type: tinyint), _col6 (type: double), (_col6 * UDFToDouble(((- _col1) + _col5))) (type: double), (- _col6) (type: double), (79.553 * _col3) (type: float), power(((_col7 - ((_col8 * _col8) / _col9)) / _col9), 0.5) (type: double), (- _col6) (type: double), power(((_col10 - ((_col11 * _col11) / _col12)) / _col12), 0.5) (type: double), (CAST( ((- _col1) + _col5) AS decimal(3,0)) - 10.175) (type: decimal(7,3)), (- (- _col6)) (type: double), (-26.28D / (- (- _col6))) (type: double), _col13 (type: float), ((_col6 * UDFToDouble(((- _col1) + _col5))) / UDFToDouble(_col1)) (type: double), _col14 (type: tinyint) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 50, 5, 52, 6, 56, 57, 58, 63, 64, 69, 73, 75, 78, 13, 84, 14] + selectExpressions: LongColUnaryMinus(col 1:tinyint) -> 50:tinyint, LongColAddLongColumn(col 51:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 51:tinyint) -> 52:tinyint, DoubleColMultiplyDoubleColumn(col 6:double, col 55:double)(children: CastLongToDouble(col 54:tinyint)(children: LongColAddLongColumn(col 53:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 53:tinyint) -> 54:tinyint) -> 55:double) -> 56:double, DoubleColUnaryMinus(col 6:double) -> 57:double, DoubleScalarMultiplyDoubleColumn(val 79.5530014038086, col 3:float) -> 58:float, FuncPowerDoubleToDouble(col 62:double)(children: DoubleColDivideLongColumn(col 61:double, col 9:bigint)(children: DoubleColSubtractDoubleColumn(col 7:double, col 60:double)(children: DoubleColDivideLongColumn(col 59:double, col 9:bigint)(children: DoubleColMultiplyDoubleColumn(col 8:double, col 8:double) -> 59:double) -> 60:double) -> 61:double) -> 62:double) -> 63:double, DoubleColUnaryMinus(col 6:double) -> 64:double, FuncPowerDoubleToDouble(col 68:double)(children: DoubleColDivideLongColumn(col 67:double, col 12:bigint)(children: DoubleColSubtractDoubleColumn(col 10:double, col 66:double)(children: DoubleColDivideLongColumn(col 65:double, col 12:bigint)(children: DoubleColMultiplyDoubleColumn(col 11:double, col 11:double) -> 65:double) -> 66:double) -> 67:double) -> 68:double) -> 69:double, DecimalColSubtractDecimalScalar(col 72:decimal(3,0), val 10.175)(children: CastLongToDecimal(col 71:tinyint)(children: LongColAddLongColumn(col 70:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 70:tinyint) -> 71:tinyint) -> 72:decimal(3,0)) -> 73:decimal(7,3), DoubleColUnaryMinus(col 74:double)(children: DoubleColUnaryMinus(col 6:double) -> 74:double) -> 75:double, DoubleScalarDivideDoubleColumn(val -26.28, col 77:double)(children: DoubleColUnaryMinus(col 76:double)(children: DoubleColUnaryMinus(col 6:double) -> 76:double) -> 77:double) -> 78:double, DoubleColDivideDoubleColumn(col 82:double, col 83:double)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 81:double)(children: CastLongToDouble(col 80:tinyint)(children: LongColAddLongColumn(col 79:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 79:tinyint) -> 80:tinyint) -> 81:double) -> 82:double, CastLongToDouble(col 1:tinyint) -> 83:double) -> 84:double + Statistics: Num rows: 693 Data size: 142684 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), _col5 (type: tinyint), _col6 (type: tinyint), _col7 (type: tinyint), _col8 (type: double), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: decimal(7,3)), _col16 (type: double), _col17 (type: double), _col18 (type: float), _col19 (type: double), _col20 (type: tinyint) + null sort order: zzzzzzzzzzzzzzzzzzzzz + sort order: +++++++++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:boolean, 1:tinyint, 2:timestamp, 3:float, 4:string, 50:tinyint, 5:tinyint, 52:tinyint, 6:double, 56:double, 57:double, 58:float, 63:double, 64:double, 69:double, 73:decimal(7,3), 75:double, 78:double, 13:float, 84:double, 14:tinyint + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 693 Data size: 142684 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -228,19 +248,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 10, 14, 15, 16, 17, 18, 19, 20] - Statistics: Num rows: 693 Data size: 219772 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 693 Data size: 142684 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 40 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 40 Data size: 12846 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 40 Data size: 8466 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 40 Data size: 12846 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 40 Data size: 8466 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -517,39 +537,59 @@ STAGE PLANS: usesVectorUDFAdaptor: false vectorized: true Reduce Operator Tree: - Group By Operator - aggregations: max(VALUE._col0), sum(VALUE._col1), sum(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6), count(VALUE._col7), max(VALUE._col8), min(VALUE._col9) - Group By Vectorization: - aggregators: VectorUDAFMaxLong(col 5:tinyint) -> tinyint, VectorUDAFSumDouble(col 6:double) -> double, VectorUDAFSumDouble(col 7:double) -> double, VectorUDAFSumDouble(col 8:double) -> double, VectorUDAFCountMerge(col 9:bigint) -> bigint, VectorUDAFSumDouble(col 10:double) -> double, VectorUDAFSumDouble(col 11:double) -> double, VectorUDAFCountMerge(col 12:bigint) -> bigint, VectorUDAFMaxDouble(col 13:float) -> float, VectorUDAFMinLong(col 14:tinyint) -> tinyint - className: VectorGroupByOperator - groupByMode: MERGEPARTIAL - keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string - native: false - vectorProcessingMode: MERGE_PARTIAL - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + Top N Key Operator + sort order: +++++ keys: KEY._col0 (type: boolean), KEY._col1 (type: tinyint), KEY._col2 (type: timestamp), KEY._col3 (type: float), KEY._col4 (type: string) - mode: mergepartial - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + null sort order: zzzzz Statistics: Num rows: 693 Data size: 122752 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), (- _col1) (type: tinyint), _col5 (type: tinyint), ((- _col1) + _col5) (type: tinyint), _col6 (type: double), (_col6 * UDFToDouble(((- _col1) + _col5))) (type: double), (- _col6) (type: double), (79.553 * _col3) (type: float), power(((_col7 - ((_col8 * _col8) / _col9)) / _col9), 0.5) (type: double), (- _col6) (type: double), power(((_col10 - ((_col11 * _col11) / _col12)) / _col12), 0.5) (type: double), (CAST( ((- _col1) + _col5) AS decimal(3,0)) - 10.175) (type: decimal(7,3)), (- (- _col6)) (type: double), (-26.28D / (- (- _col6))) (type: double), _col13 (type: float), ((_col6 * UDFToDouble(((- _col1) + _col5))) / UDFToDouble(_col1)) (type: double), _col14 (type: tinyint) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 2, 3, 4, 15, 5, 17, 6, 21, 22, 23, 28, 29, 34, 38, 40, 43, 13, 49, 14] - selectExpressions: LongColUnaryMinus(col 1:tinyint) -> 15:tinyint, LongColAddLongColumn(col 16:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 16:tinyint) -> 17:tinyint, DoubleColMultiplyDoubleColumn(col 6:double, col 20:double)(children: CastLongToDouble(col 19:tinyint)(children: LongColAddLongColumn(col 18:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 18:tinyint) -> 19:tinyint) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 6:double) -> 22:double, DoubleScalarMultiplyDoubleColumn(val 79.5530014038086, col 3:float) -> 23:float, FuncPowerDoubleToDouble(col 27:double)(children: DoubleColDivideLongColumn(col 26:double, col 9:bigint)(children: DoubleColSubtractDoubleColumn(col 7:double, col 25:double)(children: DoubleColDivideLongColumn(col 24:double, col 9:bigint)(children: DoubleColMultiplyDoubleColumn(col 8:double, col 8:double) -> 24:double) -> 25:double) -> 26:double) -> 27:double) -> 28:double, DoubleColUnaryMinus(col 6:double) -> 29:double, FuncPowerDoubleToDouble(col 33:double)(children: DoubleColDivideLongColumn(col 32:double, col 12:bigint)(children: DoubleColSubtractDoubleColumn(col 10:double, col 31:double)(children: DoubleColDivideLongColumn(col 30:double, col 12:bigint)(children: DoubleColMultiplyDoubleColumn(col 11:double, col 11:double) -> 30:double) -> 31:double) -> 32:double) -> 33:double) -> 34:double, DecimalColSubtractDecimalScalar(col 37:decimal(3,0), val 10.175)(children: CastLongToDecimal(col 36:tinyint)(children: LongColAddLongColumn(col 35:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 35:tinyint) -> 36:tinyint) -> 37:decimal(3,0)) -> 38:decimal(7,3), DoubleColUnaryMinus(col 39:double)(children: DoubleColUnaryMinus(col 6:double) -> 39:double) -> 40:double, DoubleScalarDivideDoubleColumn(val -26.28, col 42:double)(children: DoubleColUnaryMinus(col 41:double)(children: DoubleColUnaryMinus(col 6:double) -> 41:double) -> 42:double) -> 43:double, DoubleColDivideDoubleColumn(col 47:double, col 48:double)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 46:double)(children: CastLongToDouble(col 45:tinyint)(children: LongColAddLongColumn(col 44:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 44:tinyint) -> 45:tinyint) -> 46:double) -> 47:double, CastLongToDouble(col 1:tinyint) -> 48:double) -> 49:double - Statistics: Num rows: 693 Data size: 219772 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), _col5 (type: tinyint), _col6 (type: tinyint), _col7 (type: tinyint), _col8 (type: double), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: decimal(7,3)), _col16 (type: double), _col17 (type: double), _col18 (type: float), _col19 (type: double), _col20 (type: tinyint) - null sort order: zzzzzzzzzzzzzzzzzzzzz + top n: 40 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string + native: true + Group By Operator + aggregations: max(VALUE._col0), sum(VALUE._col1), sum(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6), count(VALUE._col7), max(VALUE._col8), min(VALUE._col9) + Group By Vectorization: + aggregators: VectorUDAFMaxLong(col 5:tinyint) -> tinyint, VectorUDAFSumDouble(col 6:double) -> double, VectorUDAFSumDouble(col 7:double) -> double, VectorUDAFSumDouble(col 8:double) -> double, VectorUDAFCountMerge(col 9:bigint) -> bigint, VectorUDAFSumDouble(col 10:double) -> double, VectorUDAFSumDouble(col 11:double) -> double, VectorUDAFCountMerge(col 12:bigint) -> bigint, VectorUDAFMaxDouble(col 13:float) -> float, VectorUDAFMinLong(col 14:tinyint) -> tinyint + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string + native: false + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] + keys: KEY._col0 (type: boolean), KEY._col1 (type: tinyint), KEY._col2 (type: timestamp), KEY._col3 (type: float), KEY._col4 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + Statistics: Num rows: 693 Data size: 97056 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator sort order: +++++++++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + keys: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), (- _col1) (type: tinyint), _col5 (type: tinyint), ((- _col1) + _col5) (type: tinyint), _col6 (type: double), (_col6 * UDFToDouble(((- _col1) + _col5))) (type: double), (- _col6) (type: double), (79.553 * _col3) (type: float), power(((_col7 - ((_col8 * _col8) / _col9)) / _col9), 0.5) (type: double), (- _col6) (type: double), power(((_col10 - ((_col11 * _col11) / _col12)) / _col12), 0.5) (type: double), (CAST( ((- _col1) + _col5) AS decimal(3,0)) - 10.175) (type: decimal(7,3)), (- (- _col6)) (type: double), (-26.28D / (- (- _col6))) (type: double), _col13 (type: float), ((_col6 * UDFToDouble(((- _col1) + _col5))) / UDFToDouble(_col1)) (type: double), _col14 (type: tinyint) + null sort order: zzzzzzzzzzzzzzzzzzzzz + Statistics: Num rows: 693 Data size: 97056 Basic stats: COMPLETE Column stats: COMPLETE + top n: 40 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:boolean, col 1:tinyint, col 2:timestamp, col 3:float, col 4:string, LongColUnaryMinus(col 1:tinyint) -> 15:tinyint, col 5:tinyint, LongColAddLongColumn(col 16:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 16:tinyint) -> 17:tinyint, col 6:double, DoubleColMultiplyDoubleColumn(col 6:double, col 20:double)(children: CastLongToDouble(col 19:tinyint)(children: LongColAddLongColumn(col 18:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 18:tinyint) -> 19:tinyint) -> 20:double) -> 21:double, DoubleColUnaryMinus(col 6:double) -> 22:double, DoubleScalarMultiplyDoubleColumn(val 79.5530014038086, col 3:float) -> 23:float, FuncPowerDoubleToDouble(col 27:double)(children: DoubleColDivideLongColumn(col 26:double, col 9:bigint)(children: DoubleColSubtractDoubleColumn(col 7:double, col 25:double)(children: DoubleColDivideLongColumn(col 24:double, col 9:bigint)(children: DoubleColMultiplyDoubleColumn(col 8:double, col 8:double) -> 24:double) -> 25:double) -> 26:double) -> 27:double) -> 28:double, DoubleColUnaryMinus(col 6:double) -> 29:double, FuncPowerDoubleToDouble(col 33:double)(children: DoubleColDivideLongColumn(col 32:double, col 12:bigint)(children: DoubleColSubtractDoubleColumn(col 10:double, col 31:double)(children: DoubleColDivideLongColumn(col 30:double, col 12:bigint)(children: DoubleColMultiplyDoubleColumn(col 11:double, col 11:double) -> 30:double) -> 31:double) -> 32:double) -> 33:double) -> 34:double, DecimalColSubtractDecimalScalar(col 37:decimal(3,0), val 10.175)(children: CastLongToDecimal(col 36:tinyint)(children: LongColAddLongColumn(col 35:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 35:tinyint) -> 36:tinyint) -> 37:decimal(3,0)) -> 38:decimal(7,3), DoubleColUnaryMinus(col 39:double)(children: DoubleColUnaryMinus(col 6:double) -> 39:double) -> 40:double, DoubleScalarDivideDoubleColumn(val -26.28, col 42:double)(children: DoubleColUnaryMinus(col 41:double)(children: DoubleColUnaryMinus(col 6:double) -> 41:double) -> 42:double) -> 43:double, col 13:float, DoubleColDivideDoubleColumn(col 47:double, col 48:double)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 46:double)(children: CastLongToDouble(col 45:tinyint)(children: LongColAddLongColumn(col 44:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 44:tinyint) -> 45:tinyint) -> 46:double) -> 47:double, CastLongToDouble(col 1:tinyint) -> 48:double) -> 49:double, col 14:tinyint native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 693 Data size: 219772 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Select Operator + expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), (- _col1) (type: tinyint), _col5 (type: tinyint), ((- _col1) + _col5) (type: tinyint), _col6 (type: double), (_col6 * UDFToDouble(((- _col1) + _col5))) (type: double), (- _col6) (type: double), (79.553 * _col3) (type: float), power(((_col7 - ((_col8 * _col8) / _col9)) / _col9), 0.5) (type: double), (- _col6) (type: double), power(((_col10 - ((_col11 * _col11) / _col12)) / _col12), 0.5) (type: double), (CAST( ((- _col1) + _col5) AS decimal(3,0)) - 10.175) (type: decimal(7,3)), (- (- _col6)) (type: double), (-26.28D / (- (- _col6))) (type: double), _col13 (type: float), ((_col6 * UDFToDouble(((- _col1) + _col5))) / UDFToDouble(_col1)) (type: double), _col14 (type: tinyint) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [0, 1, 2, 3, 4, 50, 5, 52, 6, 56, 57, 58, 63, 64, 69, 73, 75, 78, 13, 84, 14] + selectExpressions: LongColUnaryMinus(col 1:tinyint) -> 50:tinyint, LongColAddLongColumn(col 51:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 51:tinyint) -> 52:tinyint, DoubleColMultiplyDoubleColumn(col 6:double, col 55:double)(children: CastLongToDouble(col 54:tinyint)(children: LongColAddLongColumn(col 53:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 53:tinyint) -> 54:tinyint) -> 55:double) -> 56:double, DoubleColUnaryMinus(col 6:double) -> 57:double, DoubleScalarMultiplyDoubleColumn(val 79.5530014038086, col 3:float) -> 58:float, FuncPowerDoubleToDouble(col 62:double)(children: DoubleColDivideLongColumn(col 61:double, col 9:bigint)(children: DoubleColSubtractDoubleColumn(col 7:double, col 60:double)(children: DoubleColDivideLongColumn(col 59:double, col 9:bigint)(children: DoubleColMultiplyDoubleColumn(col 8:double, col 8:double) -> 59:double) -> 60:double) -> 61:double) -> 62:double) -> 63:double, DoubleColUnaryMinus(col 6:double) -> 64:double, FuncPowerDoubleToDouble(col 68:double)(children: DoubleColDivideLongColumn(col 67:double, col 12:bigint)(children: DoubleColSubtractDoubleColumn(col 10:double, col 66:double)(children: DoubleColDivideLongColumn(col 65:double, col 12:bigint)(children: DoubleColMultiplyDoubleColumn(col 11:double, col 11:double) -> 65:double) -> 66:double) -> 67:double) -> 68:double) -> 69:double, DecimalColSubtractDecimalScalar(col 72:decimal(3,0), val 10.175)(children: CastLongToDecimal(col 71:tinyint)(children: LongColAddLongColumn(col 70:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 70:tinyint) -> 71:tinyint) -> 72:decimal(3,0)) -> 73:decimal(7,3), DoubleColUnaryMinus(col 74:double)(children: DoubleColUnaryMinus(col 6:double) -> 74:double) -> 75:double, DoubleScalarDivideDoubleColumn(val -26.28, col 77:double)(children: DoubleColUnaryMinus(col 76:double)(children: DoubleColUnaryMinus(col 6:double) -> 76:double) -> 77:double) -> 78:double, DoubleColDivideDoubleColumn(col 82:double, col 83:double)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 81:double)(children: CastLongToDouble(col 80:tinyint)(children: LongColAddLongColumn(col 79:tinyint, col 5:tinyint)(children: LongColUnaryMinus(col 1:tinyint) -> 79:tinyint) -> 80:tinyint) -> 81:double) -> 82:double, CastLongToDouble(col 1:tinyint) -> 83:double) -> 84:double + Statistics: Num rows: 693 Data size: 142684 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: boolean), _col1 (type: tinyint), _col2 (type: timestamp), _col3 (type: float), _col4 (type: string), _col5 (type: tinyint), _col6 (type: tinyint), _col7 (type: tinyint), _col8 (type: double), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: decimal(7,3)), _col16 (type: double), _col17 (type: double), _col18 (type: float), _col19 (type: double), _col20 (type: tinyint) + null sort order: zzzzzzzzzzzzzzzzzzzzz + sort order: +++++++++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 693 Data size: 142684 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -566,19 +606,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 10, 14, 15, 16, 17, 18, 19, 20] - Statistics: Num rows: 693 Data size: 219772 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 693 Data size: 142684 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 40 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 40 Data size: 12846 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 40 Data size: 8466 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 40 Data size: 12846 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 40 Data size: 8466 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git ql/src/test/results/clientpositive/llap/vectorization_7.q.out ql/src/test/results/clientpositive/llap/vectorization_7.q.out index bfcd6a3568..6f5f3a6a68 100644 --- ql/src/test/results/clientpositive/llap/vectorization_7.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_7.q.out @@ -88,26 +88,36 @@ STAGE PLANS: predicateExpression: FilterExprAndExpr(children: FilterExprOrExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 988888.0), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28815.0)(children: CastTimestampToDouble(col 9:timestamp) -> 13:double), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 3569.0))), FilterExprOrExpr(children: FilterDoubleColLessEqualDoubleScalar(col 14:double, val -28800.0)(children: CastTimestampToDouble(col 8:timestamp) -> 14:double), FilterLongColEqualLongColumn(col 0:int, col 2:int)(children: col 0:tinyint), FilterStringColLikeStringScalar(col 7:string, pattern ss)), FilterLongColNotEqualLongScalar(col 0:tinyint, val 0)) predicate: (((cdouble > 988888.0D) or ((UDFToDouble(ctimestamp2) > -28815.0D) and (cdouble <= 3569.0D))) and ((UDFToDouble(ctimestamp1) <= -28800.0D) or (UDFToInteger(ctinyint) = cint) or (cstring2 like 'ss')) and (ctinyint <> 0Y)) (type: boolean) Statistics: Num rows: 11033 Data size: 2487724 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cboolean1 (type: boolean), cbigint (type: bigint), csmallint (type: smallint), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cstring1 (type: string), (cbigint + cbigint) (type: bigint), (UDFToInteger(csmallint) % -257) (type: int), (- csmallint) (type: smallint), (- ctinyint) (type: tinyint), (UDFToInteger((- ctinyint)) + 17) (type: int), (cbigint * UDFToLong((- csmallint))) (type: bigint), (cint % UDFToInteger(csmallint)) (type: int), (- ctinyint) (type: tinyint), ((- ctinyint) % ctinyint) (type: tinyint) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++++++++ + keys: cboolean1 (type: boolean), cbigint (type: bigint), csmallint (type: smallint), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cstring1 (type: string), (cbigint + cbigint) (type: bigint), (UDFToInteger(csmallint) % -257) (type: int), (- csmallint) (type: smallint), (- ctinyint) (type: tinyint), (UDFToInteger((- ctinyint)) + 17) (type: int), (cbigint * UDFToLong((- csmallint))) (type: bigint), (cint % UDFToInteger(csmallint)) (type: int), (- ctinyint) (type: tinyint), ((- ctinyint) % ctinyint) (type: tinyint) + null sort order: zzzzzzzzzzzzzzz + Statistics: Num rows: 11033 Data size: 2487724 Basic stats: COMPLETE Column stats: COMPLETE + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 10:boolean, col 3:bigint, col 1:smallint, col 0:tinyint, col 8:timestamp, col 6:string, LongColAddLongColumn(col 3:bigint, col 3:bigint) -> 15:bigint, LongColModuloLongScalar(col 1:int, val -257)(children: col 1:smallint) -> 16:int, LongColUnaryMinus(col 1:smallint) -> 17:smallint, LongColUnaryMinus(col 0:tinyint) -> 18:tinyint, LongColAddLongScalar(col 19:int, val 17)(children: LongColUnaryMinus(col 0:tinyint) -> 19:tinyint) -> 20:int, LongColMultiplyLongColumn(col 3:bigint, col 21:bigint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:bigint, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 23:int, LongColUnaryMinus(col 0:tinyint) -> 24:tinyint, LongColModuloLongColumn(col 25:tinyint, col 0:tinyint)(children: LongColUnaryMinus(col 0:tinyint) -> 25:tinyint) -> 26:tinyint native: true - projectedOutputColumnNums: [10, 3, 1, 0, 8, 6, 15, 16, 17, 18, 20, 22, 23, 24, 26] - selectExpressions: LongColAddLongColumn(col 3:bigint, col 3:bigint) -> 15:bigint, LongColModuloLongScalar(col 1:int, val -257)(children: col 1:smallint) -> 16:int, LongColUnaryMinus(col 1:smallint) -> 17:smallint, LongColUnaryMinus(col 0:tinyint) -> 18:tinyint, LongColAddLongScalar(col 19:int, val 17)(children: LongColUnaryMinus(col 0:tinyint) -> 19:tinyint) -> 20:int, LongColMultiplyLongColumn(col 3:bigint, col 21:bigint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:bigint, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 23:int, LongColUnaryMinus(col 0:tinyint) -> 24:tinyint, LongColModuloLongColumn(col 25:tinyint, col 0:tinyint)(children: LongColUnaryMinus(col 0:tinyint) -> 25:tinyint) -> 26:tinyint - Statistics: Num rows: 11033 Data size: 1754052 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: boolean), _col1 (type: bigint), _col2 (type: smallint), _col3 (type: tinyint), _col4 (type: timestamp), _col5 (type: string), _col6 (type: bigint), _col7 (type: int), _col8 (type: smallint), _col9 (type: tinyint), _col10 (type: int), _col11 (type: bigint), _col12 (type: int), _col13 (type: tinyint), _col14 (type: tinyint) - null sort order: zzzzzzzzzzzzzzz - sort order: +++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 10:boolean, 3:bigint, 1:smallint, 0:tinyint, 8:timestamp, 6:string, 15:bigint, 16:int, 17:smallint, 18:tinyint, 20:int, 22:bigint, 23:int, 24:tinyint, 26:tinyint + Select Operator + expressions: cboolean1 (type: boolean), cbigint (type: bigint), csmallint (type: smallint), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cstring1 (type: string), (cbigint + cbigint) (type: bigint), (UDFToInteger(csmallint) % -257) (type: int), (- csmallint) (type: smallint), (- ctinyint) (type: tinyint), (UDFToInteger((- ctinyint)) + 17) (type: int), (cbigint * UDFToLong((- csmallint))) (type: bigint), (cint % UDFToInteger(csmallint)) (type: int), (- ctinyint) (type: tinyint), ((- ctinyint) % ctinyint) (type: tinyint) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 11033 Data size: 1754052 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [10, 3, 1, 0, 8, 6, 27, 28, 29, 30, 32, 34, 35, 36, 38] + selectExpressions: LongColAddLongColumn(col 3:bigint, col 3:bigint) -> 27:bigint, LongColModuloLongScalar(col 1:int, val -257)(children: col 1:smallint) -> 28:int, LongColUnaryMinus(col 1:smallint) -> 29:smallint, LongColUnaryMinus(col 0:tinyint) -> 30:tinyint, LongColAddLongScalar(col 31:int, val 17)(children: LongColUnaryMinus(col 0:tinyint) -> 31:tinyint) -> 32:int, LongColMultiplyLongColumn(col 3:bigint, col 33:bigint)(children: LongColUnaryMinus(col 1:smallint) -> 33:smallint) -> 34:bigint, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 35:int, LongColUnaryMinus(col 0:tinyint) -> 36:tinyint, LongColModuloLongColumn(col 37:tinyint, col 0:tinyint)(children: LongColUnaryMinus(col 0:tinyint) -> 37:tinyint) -> 38:tinyint + Statistics: Num rows: 11033 Data size: 1323416 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: boolean), _col1 (type: bigint), _col2 (type: smallint), _col3 (type: tinyint), _col4 (type: timestamp), _col5 (type: string), _col6 (type: bigint), _col7 (type: int), _col8 (type: smallint), _col9 (type: tinyint), _col10 (type: int), _col11 (type: bigint), _col12 (type: int), _col13 (type: tinyint), _col14 (type: tinyint) + null sort order: zzzzzzzzzzzzzzz + sort order: +++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 10:boolean, 3:bigint, 1:smallint, 0:tinyint, 8:timestamp, 6:string, 27:bigint, 28:int, 29:smallint, 30:tinyint, 32:int, 34:bigint, 35:int, 36:tinyint, 38:tinyint + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 11033 Data size: 1323416 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -124,7 +134,7 @@ STAGE PLANS: includeColumns: [0, 1, 2, 3, 5, 6, 7, 8, 9, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint] + scratchColumnTypeNames: [double, double, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint, bigint] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -148,19 +158,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 9, 14] - Statistics: Num rows: 11033 Data size: 1754052 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 11033 Data size: 1323416 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 25 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 25 Data size: 4180 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 25 Data size: 3102 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 25 Data size: 4180 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 25 Data size: 3102 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -342,25 +352,35 @@ STAGE PLANS: predicateExpression: FilterExprAndExpr(children: FilterExprOrExpr(children: FilterDoubleColGreaterDoubleScalar(col 5:double, val 988888.0), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleScalar(col 13:double, val -28792.315)(children: CastTimestampToDouble(col 9:timestamp) -> 13:double), FilterDoubleColLessEqualDoubleScalar(col 5:double, val 3569.0))), FilterExprOrExpr(children: FilterDoubleColLessEqualDoubleScalar(col 14:double, val -28800.0)(children: CastTimestampToDouble(col 8:timestamp) -> 14:double), FilterLongColEqualLongColumn(col 0:int, col 2:int)(children: col 0:tinyint), FilterStringColLikeStringScalar(col 7:string, pattern ss)), FilterLongColNotEqualLongScalar(col 0:tinyint, val 0)) predicate: (((cdouble > 988888.0D) or ((UDFToDouble(ctimestamp2) > -28792.315D) and (cdouble <= 3569.0D))) and ((UDFToDouble(ctimestamp1) <= -28800.0D) or (UDFToInteger(ctinyint) = cint) or (cstring2 like 'ss')) and (ctinyint <> 0Y)) (type: boolean) Statistics: Num rows: 11033 Data size: 2487724 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cboolean1 (type: boolean), cbigint (type: bigint), csmallint (type: smallint), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cstring1 (type: string), (cbigint + cbigint) (type: bigint), (UDFToInteger(csmallint) % -257) (type: int), (- csmallint) (type: smallint), (- ctinyint) (type: tinyint), (UDFToInteger((- ctinyint)) + 17) (type: int), (cbigint * UDFToLong((- csmallint))) (type: bigint), (cint % UDFToInteger(csmallint)) (type: int), (- ctinyint) (type: tinyint), ((- ctinyint) % ctinyint) (type: tinyint) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++++++++ + keys: cboolean1 (type: boolean), cbigint (type: bigint), csmallint (type: smallint), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cstring1 (type: string), (cbigint + cbigint) (type: bigint), (UDFToInteger(csmallint) % -257) (type: int), (- csmallint) (type: smallint), (- ctinyint) (type: tinyint), (UDFToInteger((- ctinyint)) + 17) (type: int), (cbigint * UDFToLong((- csmallint))) (type: bigint), (cint % UDFToInteger(csmallint)) (type: int), (- ctinyint) (type: tinyint), ((- ctinyint) % ctinyint) (type: tinyint) + null sort order: zzzzzzzzzzzzzzz + Statistics: Num rows: 11033 Data size: 2487724 Basic stats: COMPLETE Column stats: COMPLETE + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 10:boolean, col 3:bigint, col 1:smallint, col 0:tinyint, col 8:timestamp, col 6:string, LongColAddLongColumn(col 3:bigint, col 3:bigint) -> 15:bigint, LongColModuloLongScalar(col 1:int, val -257)(children: col 1:smallint) -> 16:int, LongColUnaryMinus(col 1:smallint) -> 17:smallint, LongColUnaryMinus(col 0:tinyint) -> 18:tinyint, LongColAddLongScalar(col 19:int, val 17)(children: LongColUnaryMinus(col 0:tinyint) -> 19:tinyint) -> 20:int, LongColMultiplyLongColumn(col 3:bigint, col 21:bigint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:bigint, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 23:int, LongColUnaryMinus(col 0:tinyint) -> 24:tinyint, LongColModuloLongColumn(col 25:tinyint, col 0:tinyint)(children: LongColUnaryMinus(col 0:tinyint) -> 25:tinyint) -> 26:tinyint native: true - projectedOutputColumnNums: [10, 3, 1, 0, 8, 6, 15, 16, 17, 18, 20, 22, 23, 24, 26] - selectExpressions: LongColAddLongColumn(col 3:bigint, col 3:bigint) -> 15:bigint, LongColModuloLongScalar(col 1:int, val -257)(children: col 1:smallint) -> 16:int, LongColUnaryMinus(col 1:smallint) -> 17:smallint, LongColUnaryMinus(col 0:tinyint) -> 18:tinyint, LongColAddLongScalar(col 19:int, val 17)(children: LongColUnaryMinus(col 0:tinyint) -> 19:tinyint) -> 20:int, LongColMultiplyLongColumn(col 3:bigint, col 21:bigint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:bigint, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 23:int, LongColUnaryMinus(col 0:tinyint) -> 24:tinyint, LongColModuloLongColumn(col 25:tinyint, col 0:tinyint)(children: LongColUnaryMinus(col 0:tinyint) -> 25:tinyint) -> 26:tinyint - Statistics: Num rows: 11033 Data size: 1754052 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: boolean), _col1 (type: bigint), _col2 (type: smallint), _col3 (type: tinyint), _col4 (type: timestamp), _col5 (type: string), _col6 (type: bigint), _col7 (type: int), _col8 (type: smallint), _col9 (type: tinyint), _col10 (type: int), _col11 (type: bigint), _col12 (type: int), _col13 (type: tinyint), _col14 (type: tinyint) - null sort order: zzzzzzzzzzzzzzz - sort order: +++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: cboolean1 (type: boolean), cbigint (type: bigint), csmallint (type: smallint), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cstring1 (type: string), (cbigint + cbigint) (type: bigint), (UDFToInteger(csmallint) % -257) (type: int), (- csmallint) (type: smallint), (- ctinyint) (type: tinyint), (UDFToInteger((- ctinyint)) + 17) (type: int), (cbigint * UDFToLong((- csmallint))) (type: bigint), (cint % UDFToInteger(csmallint)) (type: int), (- ctinyint) (type: tinyint), ((- ctinyint) % ctinyint) (type: tinyint) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 11033 Data size: 1754052 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [10, 3, 1, 0, 8, 6, 27, 28, 29, 30, 32, 34, 35, 36, 38] + selectExpressions: LongColAddLongColumn(col 3:bigint, col 3:bigint) -> 27:bigint, LongColModuloLongScalar(col 1:int, val -257)(children: col 1:smallint) -> 28:int, LongColUnaryMinus(col 1:smallint) -> 29:smallint, LongColUnaryMinus(col 0:tinyint) -> 30:tinyint, LongColAddLongScalar(col 31:int, val 17)(children: LongColUnaryMinus(col 0:tinyint) -> 31:tinyint) -> 32:int, LongColMultiplyLongColumn(col 3:bigint, col 33:bigint)(children: LongColUnaryMinus(col 1:smallint) -> 33:smallint) -> 34:bigint, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 35:int, LongColUnaryMinus(col 0:tinyint) -> 36:tinyint, LongColModuloLongColumn(col 37:tinyint, col 0:tinyint)(children: LongColUnaryMinus(col 0:tinyint) -> 37:tinyint) -> 38:tinyint + Statistics: Num rows: 11033 Data size: 1323416 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: boolean), _col1 (type: bigint), _col2 (type: smallint), _col3 (type: tinyint), _col4 (type: timestamp), _col5 (type: string), _col6 (type: bigint), _col7 (type: int), _col8 (type: smallint), _col9 (type: tinyint), _col10 (type: int), _col11 (type: bigint), _col12 (type: int), _col13 (type: tinyint), _col14 (type: tinyint) + null sort order: zzzzzzzzzzzzzzz + sort order: +++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 11033 Data size: 1323416 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -388,19 +408,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 9, 14] - Statistics: Num rows: 11033 Data size: 1754052 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 11033 Data size: 1323416 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 25 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 25 Data size: 4180 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 25 Data size: 3102 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 25 Data size: 4180 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 25 Data size: 3102 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git ql/src/test/results/clientpositive/llap/vectorization_8.q.out ql/src/test/results/clientpositive/llap/vectorization_8.q.out index 1253c2bc83..4cd53cb311 100644 --- ql/src/test/results/clientpositive/llap/vectorization_8.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_8.q.out @@ -84,26 +84,36 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val -6432.0), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleScalar(col 13:double, val 10.0)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val 16.0)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), SelectColumnIsNotNull(col 7:string)), FilterExprAndExpr(children: FilterDoubleColEqualDoubleScalar(col 5:double, val 988888.0), SelectColumnIsNotNull(col 10:boolean))) predicate: ((cfloat < -6432.0) or ((UDFToDouble(ctimestamp1) <= 10.0D) and (UDFToDouble(ctimestamp2) <> 16.0D) and cstring2 is not null) or ((cdouble = 988888.0D) and cboolean1 is not null)) (type: boolean) Statistics: Num rows: 3059 Data size: 680930 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: ctimestamp1 (type: timestamp), cdouble (type: double), cboolean1 (type: boolean), cstring1 (type: string), cfloat (type: float), (- cdouble) (type: double), (-5638.15D - cdouble) (type: double), (cdouble * -257.0D) (type: double), (UDFToFloat(cint) + cfloat) (type: float), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (- cdouble) (type: double), (-1.389 - cfloat) (type: float), (- cfloat) (type: float), ((-5638.15D - cdouble) + UDFToDouble((UDFToFloat(cint) + cfloat))) (type: double) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: ++++++++++++++ + keys: ctimestamp1 (type: timestamp), cdouble (type: double), cboolean1 (type: boolean), cstring1 (type: string), cfloat (type: float), (- cdouble) (type: double), (-5638.15D - cdouble) (type: double), (cdouble * -257.0D) (type: double), (UDFToFloat(cint) + cfloat) (type: float), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (- cdouble) (type: double), (-1.389 - cfloat) (type: float), (- cfloat) (type: float), ((-5638.15D - cdouble) + UDFToDouble((UDFToFloat(cint) + cfloat))) (type: double) + null sort order: zzzzzzzzzzzzzz + Statistics: Num rows: 3059 Data size: 680930 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 8:timestamp, col 5:double, col 10:boolean, col 6:string, col 4:float, DoubleColUnaryMinus(col 5:double) -> 15:double, DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 16:double, DoubleColMultiplyDoubleScalar(col 5:double, val -257.0) -> 17:double, DoubleColAddDoubleColumn(col 18:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 18:float) -> 19:float, DoubleColAddDoubleColumn(col 20:double, col 21:double)(children: DoubleColUnaryMinus(col 5:double) -> 20:double, CastLongToDouble(col 3:bigint) -> 21:double) -> 22:double, DoubleColUnaryMinus(col 5:double) -> 23:double, DoubleScalarSubtractDoubleColumn(val -1.3890000581741333, col 4:float) -> 24:float, DoubleColUnaryMinus(col 4:float) -> 25:float, DoubleColAddDoubleColumn(col 26:double, col 28:double)(children: DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 26:double, DoubleColAddDoubleColumn(col 27:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 27:float) -> 28:float) -> 29:double native: true - projectedOutputColumnNums: [8, 5, 10, 6, 4, 15, 16, 17, 19, 22, 23, 24, 25, 29] - selectExpressions: DoubleColUnaryMinus(col 5:double) -> 15:double, DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 16:double, DoubleColMultiplyDoubleScalar(col 5:double, val -257.0) -> 17:double, DoubleColAddDoubleColumn(col 18:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 18:float) -> 19:float, DoubleColAddDoubleColumn(col 20:double, col 21:double)(children: DoubleColUnaryMinus(col 5:double) -> 20:double, CastLongToDouble(col 3:bigint) -> 21:double) -> 22:double, DoubleColUnaryMinus(col 5:double) -> 23:double, DoubleScalarSubtractDoubleColumn(val -1.3890000581741333, col 4:float) -> 24:float, DoubleColUnaryMinus(col 4:float) -> 25:float, DoubleColAddDoubleColumn(col 26:double, col 28:double)(children: DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 26:double, DoubleColAddDoubleColumn(col 27:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 27:float) -> 28:float) -> 29:double - Statistics: Num rows: 3059 Data size: 526290 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: timestamp), _col1 (type: double), _col2 (type: boolean), _col3 (type: string), _col4 (type: float), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: float), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: float), _col13 (type: double) - null sort order: zzzzzzzzzzzzzz - sort order: ++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 8:timestamp, 5:double, 10:boolean, 6:string, 4:float, 15:double, 16:double, 17:double, 19:float, 22:double, 23:double, 24:float, 25:float, 29:double + Select Operator + expressions: ctimestamp1 (type: timestamp), cdouble (type: double), cboolean1 (type: boolean), cstring1 (type: string), cfloat (type: float), (- cdouble) (type: double), (-5638.15D - cdouble) (type: double), (cdouble * -257.0D) (type: double), (UDFToFloat(cint) + cfloat) (type: float), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (- cdouble) (type: double), (-1.389 - cfloat) (type: float), (- cfloat) (type: float), ((-5638.15D - cdouble) + UDFToDouble((UDFToFloat(cint) + cfloat))) (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 3059 Data size: 526290 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [8, 5, 10, 6, 4, 13, 14, 30, 32, 35, 36, 37, 38, 42] + selectExpressions: DoubleColUnaryMinus(col 5:double) -> 13:double, DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 14:double, DoubleColMultiplyDoubleScalar(col 5:double, val -257.0) -> 30:double, DoubleColAddDoubleColumn(col 31:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 31:float) -> 32:float, DoubleColAddDoubleColumn(col 33:double, col 34:double)(children: DoubleColUnaryMinus(col 5:double) -> 33:double, CastLongToDouble(col 3:bigint) -> 34:double) -> 35:double, DoubleColUnaryMinus(col 5:double) -> 36:double, DoubleScalarSubtractDoubleColumn(val -1.3890000581741333, col 4:float) -> 37:float, DoubleColUnaryMinus(col 4:float) -> 38:float, DoubleColAddDoubleColumn(col 39:double, col 41:double)(children: DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 39:double, DoubleColAddDoubleColumn(col 40:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 40:float) -> 41:float) -> 42:double + Statistics: Num rows: 3059 Data size: 410040 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: timestamp), _col1 (type: double), _col2 (type: boolean), _col3 (type: string), _col4 (type: float), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: float), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: float), _col13 (type: double) + null sort order: zzzzzzzzzzzzzz + sort order: ++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 8:timestamp, 5:double, 10:boolean, 6:string, 4:float, 13:double, 14:double, 30:double, 32:float, 35:double, 36:double, 37:float, 38:float, 42:double + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 3059 Data size: 410040 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -120,7 +130,7 @@ STAGE PLANS: includeColumns: [2, 3, 4, 5, 6, 7, 8, 9, 10] dataColumns: ctinyint:tinyint, csmallint:smallint, cint:int, cbigint:bigint, cfloat:float, cdouble:double, cstring1:string, cstring2:string, ctimestamp1:timestamp, ctimestamp2:timestamp, cboolean1:boolean, cboolean2:boolean partitionColumnCount: 0 - scratchColumnTypeNames: [double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double] + scratchColumnTypeNames: [double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double, double] Reducer 2 Execution mode: vectorized, llap Reduce Vectorization: @@ -144,19 +154,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 11, 12, 13] - Statistics: Num rows: 3059 Data size: 526290 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 3059 Data size: 410040 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 3600 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 2850 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 3600 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 2850 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -325,25 +335,35 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterDoubleColLessDoubleScalar(col 4:float, val -6432.0), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleScalar(col 13:double, val 12.503)(children: CastTimestampToDouble(col 8:timestamp) -> 13:double), FilterDoubleColNotEqualDoubleScalar(col 14:double, val 11.998)(children: CastTimestampToDouble(col 9:timestamp) -> 14:double), SelectColumnIsNotNull(col 7:string)), FilterExprAndExpr(children: FilterDoubleColEqualDoubleScalar(col 5:double, val 988888.0), SelectColumnIsNotNull(col 10:boolean))) predicate: ((cfloat < -6432.0) or ((UDFToDouble(ctimestamp1) <= 12.503D) and (UDFToDouble(ctimestamp2) <> 11.998D) and cstring2 is not null) or ((cdouble = 988888.0D) and cboolean1 is not null)) (type: boolean) Statistics: Num rows: 3059 Data size: 680930 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: ctimestamp1 (type: timestamp), cdouble (type: double), cboolean1 (type: boolean), cstring1 (type: string), cfloat (type: float), (- cdouble) (type: double), (-5638.15D - cdouble) (type: double), (cdouble * -257.0D) (type: double), (UDFToFloat(cint) + cfloat) (type: float), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (- cdouble) (type: double), (-1.389 - cfloat) (type: float), (- cfloat) (type: float), ((-5638.15D - cdouble) + UDFToDouble((UDFToFloat(cint) + cfloat))) (type: double) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: ++++++++++++++ + keys: ctimestamp1 (type: timestamp), cdouble (type: double), cboolean1 (type: boolean), cstring1 (type: string), cfloat (type: float), (- cdouble) (type: double), (-5638.15D - cdouble) (type: double), (cdouble * -257.0D) (type: double), (UDFToFloat(cint) + cfloat) (type: float), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (- cdouble) (type: double), (-1.389 - cfloat) (type: float), (- cfloat) (type: float), ((-5638.15D - cdouble) + UDFToDouble((UDFToFloat(cint) + cfloat))) (type: double) + null sort order: zzzzzzzzzzzzzz + Statistics: Num rows: 3059 Data size: 680930 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 8:timestamp, col 5:double, col 10:boolean, col 6:string, col 4:float, DoubleColUnaryMinus(col 5:double) -> 15:double, DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 16:double, DoubleColMultiplyDoubleScalar(col 5:double, val -257.0) -> 17:double, DoubleColAddDoubleColumn(col 18:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 18:float) -> 19:float, DoubleColAddDoubleColumn(col 20:double, col 21:double)(children: DoubleColUnaryMinus(col 5:double) -> 20:double, CastLongToDouble(col 3:bigint) -> 21:double) -> 22:double, DoubleColUnaryMinus(col 5:double) -> 23:double, DoubleScalarSubtractDoubleColumn(val -1.3890000581741333, col 4:float) -> 24:float, DoubleColUnaryMinus(col 4:float) -> 25:float, DoubleColAddDoubleColumn(col 26:double, col 28:double)(children: DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 26:double, DoubleColAddDoubleColumn(col 27:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 27:float) -> 28:float) -> 29:double native: true - projectedOutputColumnNums: [8, 5, 10, 6, 4, 15, 16, 17, 19, 22, 23, 24, 25, 29] - selectExpressions: DoubleColUnaryMinus(col 5:double) -> 15:double, DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 16:double, DoubleColMultiplyDoubleScalar(col 5:double, val -257.0) -> 17:double, DoubleColAddDoubleColumn(col 18:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 18:float) -> 19:float, DoubleColAddDoubleColumn(col 20:double, col 21:double)(children: DoubleColUnaryMinus(col 5:double) -> 20:double, CastLongToDouble(col 3:bigint) -> 21:double) -> 22:double, DoubleColUnaryMinus(col 5:double) -> 23:double, DoubleScalarSubtractDoubleColumn(val -1.3890000581741333, col 4:float) -> 24:float, DoubleColUnaryMinus(col 4:float) -> 25:float, DoubleColAddDoubleColumn(col 26:double, col 28:double)(children: DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 26:double, DoubleColAddDoubleColumn(col 27:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 27:float) -> 28:float) -> 29:double - Statistics: Num rows: 3059 Data size: 526290 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: timestamp), _col1 (type: double), _col2 (type: boolean), _col3 (type: string), _col4 (type: float), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: float), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: float), _col13 (type: double) - null sort order: zzzzzzzzzzzzzz - sort order: ++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: ctimestamp1 (type: timestamp), cdouble (type: double), cboolean1 (type: boolean), cstring1 (type: string), cfloat (type: float), (- cdouble) (type: double), (-5638.15D - cdouble) (type: double), (cdouble * -257.0D) (type: double), (UDFToFloat(cint) + cfloat) (type: float), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (- cdouble) (type: double), (-1.389 - cfloat) (type: float), (- cfloat) (type: float), ((-5638.15D - cdouble) + UDFToDouble((UDFToFloat(cint) + cfloat))) (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 3059 Data size: 526290 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [8, 5, 10, 6, 4, 13, 14, 30, 32, 35, 36, 37, 38, 42] + selectExpressions: DoubleColUnaryMinus(col 5:double) -> 13:double, DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 14:double, DoubleColMultiplyDoubleScalar(col 5:double, val -257.0) -> 30:double, DoubleColAddDoubleColumn(col 31:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 31:float) -> 32:float, DoubleColAddDoubleColumn(col 33:double, col 34:double)(children: DoubleColUnaryMinus(col 5:double) -> 33:double, CastLongToDouble(col 3:bigint) -> 34:double) -> 35:double, DoubleColUnaryMinus(col 5:double) -> 36:double, DoubleScalarSubtractDoubleColumn(val -1.3890000581741333, col 4:float) -> 37:float, DoubleColUnaryMinus(col 4:float) -> 38:float, DoubleColAddDoubleColumn(col 39:double, col 41:double)(children: DoubleScalarSubtractDoubleColumn(val -5638.15, col 5:double) -> 39:double, DoubleColAddDoubleColumn(col 40:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 40:float) -> 41:float) -> 42:double + Statistics: Num rows: 3059 Data size: 410040 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: timestamp), _col1 (type: double), _col2 (type: boolean), _col3 (type: string), _col4 (type: float), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: float), _col9 (type: double), _col10 (type: double), _col11 (type: float), _col12 (type: float), _col13 (type: double) + null sort order: zzzzzzzzzzzzzz + sort order: ++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 3059 Data size: 410040 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -371,19 +391,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 5, 11, 12, 13] - Statistics: Num rows: 3059 Data size: 526290 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 3059 Data size: 410040 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 3600 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 2850 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 3600 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 2850 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git ql/src/test/results/clientpositive/llap/vectorization_div0.q.out ql/src/test/results/clientpositive/llap/vectorization_div0.q.out index 73ca096e22..427e2767ba 100644 --- ql/src/test/results/clientpositive/llap/vectorization_div0.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_div0.q.out @@ -34,26 +34,36 @@ STAGE PLANS: Statistics: Num rows: 12288 Data size: 220184 Basic stats: COMPLETE Column stats: COMPLETE TableScan Vectorization: native: true - Select Operator - expressions: cint (type: int), (UDFToDouble(cint) / 0.0D) (type: double), ctinyint (type: tinyint), (UDFToDouble(ctinyint) / 0.0D) (type: double), cbigint (type: bigint), (UDFToDouble(cbigint) / 0.0D) (type: double), cdouble (type: double), (cdouble / 0.0D) (type: double) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: ++++ + keys: cint (type: int), ctinyint (type: tinyint), cbigint (type: bigint), cdouble (type: double) + null sort order: zzzz + Statistics: Num rows: 12288 Data size: 220184 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 2:int, col 0:tinyint, col 3:bigint, col 5:double native: true - projectedOutputColumnNums: [2, 14, 0, 16, 3, 18, 5, 19] - selectExpressions: DoubleColDivideDoubleScalar(col 13:double, val 0.0)(children: CastLongToDouble(col 2:int) -> 13:double) -> 14:double, DoubleColDivideDoubleScalar(col 15:double, val 0.0)(children: CastLongToDouble(col 0:tinyint) -> 15:double) -> 16:double, DoubleColDivideDoubleScalar(col 17:double, val 0.0)(children: CastLongToDouble(col 3:bigint) -> 17:double) -> 18:double, DoubleColDivideDoubleScalar(col 5:double, val 0.0) -> 19:double - Statistics: Num rows: 12288 Data size: 613400 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int), _col2 (type: tinyint), _col4 (type: bigint), _col6 (type: double) - null sort order: zzzz - sort order: ++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: cint (type: int), (UDFToDouble(cint) / 0.0D) (type: double), ctinyint (type: tinyint), (UDFToDouble(ctinyint) / 0.0D) (type: double), cbigint (type: bigint), (UDFToDouble(cbigint) / 0.0D) (type: double), cdouble (type: double), (cdouble / 0.0D) (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 12288 Data size: 613400 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: double), _col3 (type: double), _col5 (type: double), _col7 (type: double) + projectedOutputColumnNums: [2, 14, 0, 16, 3, 18, 5, 19] + selectExpressions: DoubleColDivideDoubleScalar(col 13:double, val 0.0)(children: CastLongToDouble(col 2:int) -> 13:double) -> 14:double, DoubleColDivideDoubleScalar(col 15:double, val 0.0)(children: CastLongToDouble(col 0:tinyint) -> 15:double) -> 16:double, DoubleColDivideDoubleScalar(col 17:double, val 0.0)(children: CastLongToDouble(col 3:bigint) -> 17:double) -> 18:double, DoubleColDivideDoubleScalar(col 5:double, val 0.0) -> 19:double + Statistics: Num rows: 12288 Data size: 538648 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col2 (type: tinyint), _col4 (type: bigint), _col6 (type: double) + null sort order: zzzz + sort order: ++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 12288 Data size: 538648 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: double), _col3 (type: double), _col5 (type: double), _col7 (type: double) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -81,19 +91,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 4, 1, 5, 2, 6, 3, 7] - Statistics: Num rows: 12288 Data size: 613400 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 12288 Data size: 538648 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 100 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 100 Data size: 5024 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 100 Data size: 4400 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 100 Data size: 5024 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 100 Data size: 4400 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -260,25 +270,35 @@ STAGE PLANS: predicateExpression: FilterExprAndExpr(children: FilterLongColGreaterLongScalar(col 3:bigint, val 0), FilterLongColLessLongScalar(col 3:bigint, val 100000000)) predicate: ((cbigint > 0L) and (cbigint < 100000000L)) (type: boolean) Statistics: Num rows: 3215 Data size: 38416 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: (cbigint - 988888L) (type: bigint), (cdouble / UDFToDouble((cbigint - 988888L))) (type: double), (1.2 / CAST( (cbigint - 988888L) AS decimal(19,0))) (type: decimal(22,21)) - outputColumnNames: _col0, _col1, _col2 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++ + keys: (cbigint - 988888L) (type: bigint), (cdouble / UDFToDouble((cbigint - 988888L))) (type: double), (1.2 / CAST( (cbigint - 988888L) AS decimal(19,0))) (type: decimal(22,21)) + null sort order: zzz + Statistics: Num rows: 3215 Data size: 38416 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 13:bigint, DoubleColDivideDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 14:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 14:bigint) -> 15:double) -> 16:double, DecimalScalarDivideDecimalColumn(val 1.2, col 18:decimal(19,0))(children: CastLongToDecimal(col 17:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 17:bigint) -> 18:decimal(19,0)) -> 19:decimal(22,21) native: true - projectedOutputColumnNums: [13, 16, 19] - selectExpressions: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 13:bigint, DoubleColDivideDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 14:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 14:bigint) -> 15:double) -> 16:double, DecimalScalarDivideDecimalColumn(val 1.2, col 18:decimal(19,0))(children: CastLongToDecimal(col 17:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 17:bigint) -> 18:decimal(19,0)) -> 19:decimal(22,21) - Statistics: Num rows: 3215 Data size: 411520 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: bigint), _col1 (type: double), _col2 (type: decimal(22,21)) - null sort order: zzz - sort order: +++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: (cbigint - 988888L) (type: bigint), (cdouble / UDFToDouble((cbigint - 988888L))) (type: double), (1.2 / CAST( (cbigint - 988888L) AS decimal(19,0))) (type: decimal(22,21)) + outputColumnNames: _col0, _col1, _col2 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [20, 23, 26] + selectExpressions: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 20:bigint, DoubleColDivideDoubleColumn(col 5:double, col 22:double)(children: CastLongToDouble(col 21:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 21:bigint) -> 22:double) -> 23:double, DecimalScalarDivideDecimalColumn(val 1.2, col 25:decimal(19,0))(children: CastLongToDecimal(col 24:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 988888) -> 24:bigint) -> 25:decimal(19,0)) -> 26:decimal(22,21) Statistics: Num rows: 3215 Data size: 411520 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: bigint), _col1 (type: double), _col2 (type: decimal(22,21)) + null sort order: zzz + sort order: +++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 3215 Data size: 411520 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -485,25 +505,35 @@ STAGE PLANS: predicateExpression: FilterExprAndExpr(children: FilterDoubleColGreaterEqualDoubleScalar(col 5:double, val -500.0), FilterDoubleColLessDoubleScalar(col 5:double, val -199.0)) predicate: ((cdouble >= -500.0D) and (cdouble < -199.0D)) (type: boolean) Statistics: Num rows: 20 Data size: 256 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: (cdouble + 200.0D) (type: double), (UDFToDouble(cbigint) / (cdouble + 200.0D)) (type: double), ((cdouble + 200.0D) / (cdouble + 200.0D)) (type: double), (UDFToDouble(cbigint) / (cdouble + 200.0D)) (type: double), (3.0D / (cdouble + 200.0D)) (type: double), (1.2D / (cdouble + 200.0D)) (type: double) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: ++++++ + keys: (cdouble + 200.0D) (type: double), (UDFToDouble(cbigint) / (cdouble + 200.0D)) (type: double), ((cdouble + 200.0D) / (cdouble + 200.0D)) (type: double), (UDFToDouble(cbigint) / (cdouble + 200.0D)) (type: double), (3.0D / (cdouble + 200.0D)) (type: double), (1.2D / (cdouble + 200.0D)) (type: double) + null sort order: zzzzzz + Statistics: Num rows: 20 Data size: 256 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 13:double, DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 14:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 15:double) -> 16:double, DoubleColDivideDoubleColumn(col 17:double, col 18:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 17:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 18:double) -> 19:double, DoubleColDivideDoubleColumn(col 20:double, col 21:double)(children: CastLongToDouble(col 3:bigint) -> 20:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 21:double) -> 22:double, DoubleScalarDivideDoubleColumn(val 3.0, col 23:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 23:double) -> 24:double, DoubleScalarDivideDoubleColumn(val 1.2, col 25:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 25:double) -> 26:double native: true - projectedOutputColumnNums: [13, 16, 19, 22, 24, 26] - selectExpressions: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 13:double, DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 14:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 15:double) -> 16:double, DoubleColDivideDoubleColumn(col 17:double, col 18:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 17:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 18:double) -> 19:double, DoubleColDivideDoubleColumn(col 20:double, col 21:double)(children: CastLongToDouble(col 3:bigint) -> 20:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 21:double) -> 22:double, DoubleScalarDivideDoubleColumn(val 3.0, col 23:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 23:double) -> 24:double, DoubleScalarDivideDoubleColumn(val 1.2, col 25:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 25:double) -> 26:double - Statistics: Num rows: 20 Data size: 960 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double) - null sort order: zzzzzz - sort order: ++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: (cdouble + 200.0D) (type: double), (UDFToDouble(cbigint) / (cdouble + 200.0D)) (type: double), ((cdouble + 200.0D) / (cdouble + 200.0D)) (type: double), (UDFToDouble(cbigint) / (cdouble + 200.0D)) (type: double), (3.0D / (cdouble + 200.0D)) (type: double), (1.2D / (cdouble + 200.0D)) (type: double) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [27, 30, 33, 36, 38, 40] + selectExpressions: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 27:double, DoubleColDivideDoubleColumn(col 28:double, col 29:double)(children: CastLongToDouble(col 3:bigint) -> 28:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 29:double) -> 30:double, DoubleColDivideDoubleColumn(col 31:double, col 32:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 31:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 32:double) -> 33:double, DoubleColDivideDoubleColumn(col 34:double, col 35:double)(children: CastLongToDouble(col 3:bigint) -> 34:double, DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 35:double) -> 36:double, DoubleScalarDivideDoubleColumn(val 3.0, col 37:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 37:double) -> 38:double, DoubleScalarDivideDoubleColumn(val 1.2, col 39:double)(children: DoubleColAddDoubleScalar(col 5:double, val 200.0) -> 39:double) -> 40:double Statistics: Num rows: 20 Data size: 960 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double) + null sort order: zzzzzz + sort order: ++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 20 Data size: 960 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -710,25 +740,35 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterLongColGreaterLongScalar(col 2:int, val 500000000), FilterDoubleColGreaterDoubleScalar(col 5:double, val 1.0E9), FilterLongColEqualLongScalar(col 0:tinyint, val 0)) predicate: ((cint > 500000000) or (cdouble > 1.0E9D) or (ctinyint = 0Y)) (type: boolean) Statistics: Num rows: 3378 Data size: 60552 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cint (type: int), cbigint (type: bigint), ctinyint (type: tinyint), (UDFToDouble(cint) / UDFToDouble((cint - 528534767))) (type: double), (UDFToDouble(cbigint) / UDFToDouble((cbigint - 1018195815L))) (type: double), (UDFToDouble(ctinyint) / UDFToDouble(ctinyint)) (type: double), (cint % (cint - 528534767)) (type: int), (cbigint % (cbigint - 1018195815L)) (type: bigint), (ctinyint % ctinyint) (type: tinyint) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++ + keys: cint (type: int), cbigint (type: bigint), ctinyint (type: tinyint), (UDFToDouble(cint) / UDFToDouble((cint - 528534767))) (type: double), (UDFToDouble(cbigint) / UDFToDouble((cbigint - 1018195815L))) (type: double), (UDFToDouble(ctinyint) / UDFToDouble(ctinyint)) (type: double), (cint % (cint - 528534767)) (type: int), (cbigint % (cbigint - 1018195815L)) (type: bigint), (ctinyint % ctinyint) (type: tinyint) + null sort order: zzzzzzzzz + Statistics: Num rows: 3378 Data size: 60552 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 2:int, col 3:bigint, col 0:tinyint, DoubleColDivideDoubleColumn(col 13:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 13:double, CastLongToDouble(col 14:int)(children: LongColSubtractLongScalar(col 2:int, val 528534767) -> 14:int) -> 15:double) -> 16:double, DoubleColDivideDoubleColumn(col 17:double, col 19:double)(children: CastLongToDouble(col 3:bigint) -> 17:double, CastLongToDouble(col 18:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 1018195815) -> 18:bigint) -> 19:double) -> 20:double, DoubleColDivideDoubleColumn(col 21:double, col 22:double)(children: CastLongToDouble(col 0:tinyint) -> 21:double, CastLongToDouble(col 0:tinyint) -> 22:double) -> 23:double, LongColModuloLongColumn(col 2:int, col 24:int)(children: LongColSubtractLongScalar(col 2:int, val 528534767) -> 24:int) -> 25:int, LongColModuloLongColumn(col 3:bigint, col 26:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 1018195815) -> 26:bigint) -> 27:bigint, LongColModuloLongColumn(col 0:tinyint, col 0:tinyint) -> 28:tinyint native: true - projectedOutputColumnNums: [2, 3, 0, 16, 20, 23, 25, 27, 28] - selectExpressions: DoubleColDivideDoubleColumn(col 13:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 13:double, CastLongToDouble(col 14:int)(children: LongColSubtractLongScalar(col 2:int, val 528534767) -> 14:int) -> 15:double) -> 16:double, DoubleColDivideDoubleColumn(col 17:double, col 19:double)(children: CastLongToDouble(col 3:bigint) -> 17:double, CastLongToDouble(col 18:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 1018195815) -> 18:bigint) -> 19:double) -> 20:double, DoubleColDivideDoubleColumn(col 21:double, col 22:double)(children: CastLongToDouble(col 0:tinyint) -> 21:double, CastLongToDouble(col 0:tinyint) -> 22:double) -> 23:double, LongColModuloLongColumn(col 2:int, col 24:int)(children: LongColSubtractLongScalar(col 2:int, val 528534767) -> 24:int) -> 25:int, LongColModuloLongColumn(col 3:bigint, col 26:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 1018195815) -> 26:bigint) -> 27:bigint, LongColModuloLongColumn(col 0:tinyint, col 0:tinyint) -> 28:tinyint - Statistics: Num rows: 3378 Data size: 175488 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: tinyint), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: int), _col7 (type: bigint), _col8 (type: tinyint) - null sort order: zzzzzzzzz - sort order: +++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: cint (type: int), cbigint (type: bigint), ctinyint (type: tinyint), (UDFToDouble(cint) / UDFToDouble((cint - 528534767))) (type: double), (UDFToDouble(cbigint) / UDFToDouble((cbigint - 1018195815L))) (type: double), (UDFToDouble(ctinyint) / UDFToDouble(ctinyint)) (type: double), (cint % (cint - 528534767)) (type: int), (cbigint % (cbigint - 1018195815L)) (type: bigint), (ctinyint % ctinyint) (type: tinyint) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 3378 Data size: 175488 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [2, 3, 0, 32, 36, 39, 41, 43, 44] + selectExpressions: DoubleColDivideDoubleColumn(col 29:double, col 31:double)(children: CastLongToDouble(col 2:int) -> 29:double, CastLongToDouble(col 30:int)(children: LongColSubtractLongScalar(col 2:int, val 528534767) -> 30:int) -> 31:double) -> 32:double, DoubleColDivideDoubleColumn(col 33:double, col 35:double)(children: CastLongToDouble(col 3:bigint) -> 33:double, CastLongToDouble(col 34:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 1018195815) -> 34:bigint) -> 35:double) -> 36:double, DoubleColDivideDoubleColumn(col 37:double, col 38:double)(children: CastLongToDouble(col 0:tinyint) -> 37:double, CastLongToDouble(col 0:tinyint) -> 38:double) -> 39:double, LongColModuloLongColumn(col 2:int, col 40:int)(children: LongColSubtractLongScalar(col 2:int, val 528534767) -> 40:int) -> 41:int, LongColModuloLongColumn(col 3:bigint, col 42:bigint)(children: LongColSubtractLongScalar(col 3:bigint, val 1018195815) -> 42:bigint) -> 43:bigint, LongColModuloLongColumn(col 0:tinyint, col 0:tinyint) -> 44:tinyint + Statistics: Num rows: 3378 Data size: 161792 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: tinyint), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: int), _col7 (type: bigint), _col8 (type: tinyint) + null sort order: zzzzzzzzz + sort order: +++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 3378 Data size: 161792 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -756,19 +796,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8] - Statistics: Num rows: 3378 Data size: 175488 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 3378 Data size: 161792 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 100 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 100 Data size: 5216 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 100 Data size: 4800 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 100 Data size: 5216 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 100 Data size: 4800 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git ql/src/test/results/clientpositive/llap/vectorization_limit.q.out ql/src/test/results/clientpositive/llap/vectorization_limit.q.out index 7326adf522..0b884bc61b 100644 --- ql/src/test/results/clientpositive/llap/vectorization_limit.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_limit.q.out @@ -34,16 +34,22 @@ STAGE PLANS: Filter Operator predicate: ((cint > 0) and (UDFToDouble(cbigint) < cdouble)) (type: boolean) Statistics: Num rows: 2048 Data size: 30600 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cbigint (type: bigint), cdouble (type: double) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 2048 Data size: 24480 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: bigint), _col1 (type: double) - null sort order: zz - sort order: ++ - Statistics: Num rows: 2048 Data size: 24480 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Top N Key Operator + sort order: ++ + keys: cbigint (type: bigint), cdouble (type: double) + null sort order: zz + Statistics: Num rows: 2048 Data size: 30600 Basic stats: COMPLETE Column stats: COMPLETE + top n: 7 + Select Operator + expressions: cbigint (type: bigint), cdouble (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 2048 Data size: 16176 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: bigint), _col1 (type: double) + null sort order: zz + sort order: ++ + Statistics: Num rows: 2048 Data size: 16176 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -67,13 +73,13 @@ STAGE PLANS: Select Operator expressions: KEY.reducesinkkey0 (type: bigint), KEY.reducesinkkey1 (type: double) outputColumnNames: _col0, _col1 - Statistics: Num rows: 2048 Data size: 24480 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 2048 Data size: 16176 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 7 - Statistics: Num rows: 7 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 7 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 7 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 7 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -143,25 +149,35 @@ STAGE PLANS: predicateExpression: SelectColumnIsNotNull(col 0:tinyint) predicate: ctinyint is not null (type: boolean) Statistics: Num rows: 9173 Data size: 109584 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: ctinyint (type: tinyint), cdouble (type: double), csmallint (type: smallint) - outputColumnNames: _col0, _col1, _col2 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 5, 1] + Top N Key Operator + sort order: +++ + keys: ctinyint (type: tinyint), cdouble (type: double), csmallint (type: smallint) + null sort order: zzz Statistics: Num rows: 9173 Data size: 109584 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint), _col1 (type: double), _col2 (type: smallint) - null sort order: zzz - sort order: +++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:tinyint, 5:double, 1:smallint + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint, col 5:double, col 1:smallint + native: true + Select Operator + expressions: ctinyint (type: tinyint), cdouble (type: double), csmallint (type: smallint) + outputColumnNames: _col0, _col1, _col2 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 9173 Data size: 109584 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 + projectedOutputColumnNums: [0, 5, 1] + Statistics: Num rows: 9173 Data size: 72384 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint), _col1 (type: double), _col2 (type: smallint) + null sort order: zzz + sort order: +++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:tinyint, 5:double, 1:smallint + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 9173 Data size: 72384 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -202,19 +218,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2] - Statistics: Num rows: 9173 Data size: 109584 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 9173 Data size: 72384 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 256 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 176 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 256 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 176 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -359,40 +375,60 @@ STAGE PLANS: partitionColumnCount: 0 scratchColumnTypeNames: [] Reduce Operator Tree: - Group By Operator - aggregations: sum(VALUE._col0), count(VALUE._col1) - Group By Vectorization: - aggregators: VectorUDAFSumDouble(col 1:double) -> double, VectorUDAFCountMerge(col 2:bigint) -> bigint - className: VectorGroupByOperator - groupByMode: MERGEPARTIAL - keyExpressions: col 0:tinyint - native: false - vectorProcessingMode: MERGE_PARTIAL - projectedOutputColumnNums: [0, 1] + Top N Key Operator + sort order: + keys: KEY._col0 (type: tinyint) - mode: mergepartial - outputColumnNames: _col0, _col1, _col2 + null sort order: z Statistics: Num rows: 131 Data size: 2492 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: tinyint), (_col1 / _col2) (type: double) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 3] - selectExpressions: DoubleColDivideLongColumn(col 1:double, col 2:bigint) -> 3:double - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint), _col1 (type: double) - null sort order: zz + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint + native: true + Group By Operator + aggregations: sum(VALUE._col0), count(VALUE._col1) + Group By Vectorization: + aggregators: VectorUDAFSumDouble(col 1:double) -> double, VectorUDAFCountMerge(col 2:bigint) -> bigint + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + keyExpressions: col 0:tinyint + native: false + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumnNums: [0, 1] + keys: KEY._col0 (type: tinyint) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 131 Data size: 2360 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:tinyint, 3:double + keys: _col0 (type: tinyint), (_col1 / _col2) (type: double) + null sort order: zz + Statistics: Num rows: 131 Data size: 2360 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint, DoubleColDivideLongColumn(col 1:double, col 2:bigint) -> 3:double native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 + Select Operator + expressions: _col0 (type: tinyint), (_col1 / _col2) (type: double) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [0, 4] + selectExpressions: DoubleColDivideLongColumn(col 1:double, col 2:bigint) -> 4:double + Statistics: Num rows: 131 Data size: 1048 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: tinyint), _col1 (type: double) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:tinyint, 4:double + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 131 Data size: 1048 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -416,19 +452,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1] - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 131 Data size: 1048 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 164 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 164 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -502,24 +538,24 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:ctinyint:tinyint, 1:csmallint:smallint, 2:cint:int, 3:cbigint:bigint, 4:cfloat:float, 5:cdouble:double, 6:cstring1:string, 7:cstring2:string, 8:ctimestamp1:timestamp, 9:ctimestamp2:timestamp, 10:cboolean1:boolean, 11:cboolean2:boolean, 12:ROW__ID:struct] - Select Operator - expressions: ctinyint (type: tinyint) - outputColumnNames: ctinyint - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0] + Top N Key Operator + sort order: + + keys: ctinyint (type: tinyint) + null sort order: z Statistics: Num rows: 12288 Data size: 36696 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: ctinyint (type: tinyint) - null sort order: z - Statistics: Num rows: 12288 Data size: 36696 Basic stats: COMPLETE Column stats: COMPLETE - top n: 20 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 0:tinyint + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint + native: true + Select Operator + expressions: ctinyint (type: tinyint) + outputColumnNames: ctinyint + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [0] + Statistics: Num rows: 12288 Data size: 36696 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator Group By Vectorization: className: VectorGroupByOperator @@ -743,43 +779,63 @@ STAGE PLANS: partitionColumnCount: 0 scratchColumnTypeNames: [] Reduce Operator Tree: - Group By Operator - Group By Vectorization: - className: VectorGroupByOperator - groupByMode: MERGEPARTIAL - keyExpressions: col 0:tinyint, col 1:double - native: false - vectorProcessingMode: MERGE_PARTIAL - projectedOutputColumnNums: [] - keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) - mode: mergepartial - outputColumnNames: _col0, _col1 + Top N Key Operator + sort order: + + keys: KEY._col0 (type: tinyint) + null sort order: z Statistics: Num rows: 6144 Data size: 55052 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint + native: true Group By Operator - aggregations: count(_col1) Group By Vectorization: - aggregators: VectorUDAFCount(col 1:double) -> bigint className: VectorGroupByOperator - groupByMode: COMPLETE - keyExpressions: col 0:tinyint + groupByMode: MERGEPARTIAL + keyExpressions: col 0:tinyint, col 1:double native: false - vectorProcessingMode: STREAMING - projectedOutputColumnNums: [0] - keys: _col0 (type: tinyint) - mode: complete + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumnNums: [] + keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) + mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: tinyint), _col1 (type: bigint) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 0:tinyint, 1:bigint - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 + Statistics: Num rows: 6144 Data size: 36364 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + aggregations: count(_col1) + Group By Vectorization: + aggregators: VectorUDAFCount(col 1:double) -> bigint + className: VectorGroupByOperator + groupByMode: COMPLETE + keyExpressions: col 0:tinyint + native: false + vectorProcessingMode: STREAMING + projectedOutputColumnNums: [0] + keys: _col0 (type: tinyint) + mode: complete + outputColumnNames: _col0, _col1 + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator + sort order: ++ + keys: _col0 (type: tinyint), _col1 (type: bigint) + null sort order: zz + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:tinyint, col 1:bigint + native: true + Reduce Output Operator + key expressions: _col0 (type: tinyint), _col1 (type: bigint) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 0:tinyint, 1:bigint + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 131 Data size: 1312 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -803,19 +859,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1] - Statistics: Num rows: 131 Data size: 1444 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 131 Data size: 1048 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 164 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 224 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 164 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -1005,17 +1061,27 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 4586 Data size: 64088 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col1 (type: bigint), _col0 (type: double) - null sort order: zz + Top N Key Operator sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - keyColumns: 1:bigint, 0:double - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + keys: _col1 (type: bigint), _col0 (type: double) + null sort order: zz Statistics: Num rows: 4586 Data size: 64088 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.3 + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 1:bigint, col 0:double + native: true + Reduce Output Operator + key expressions: _col1 (type: bigint), _col0 (type: double) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + keyColumns: 1:bigint, 0:double + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 4586 Data size: 64088 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.3 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -1039,19 +1105,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [1, 0] - Statistics: Num rows: 4586 Data size: 64088 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 4586 Data size: 54792 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 288 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 288 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 248 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git ql/src/test/results/clientpositive/llap/vectorization_part_project.q.out ql/src/test/results/clientpositive/llap/vectorization_part_project.q.out index 1c22230f2d..a3abdebde0 100644 --- ql/src/test/results/clientpositive/llap/vectorization_part_project.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_part_project.q.out @@ -79,16 +79,22 @@ STAGE PLANS: TableScan alias: alltypesorc_part Statistics: Num rows: 200 Data size: 1600 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: (cdouble + 2.0D) (type: double) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: (cdouble + 2.0D) (type: double) + null sort order: z Statistics: Num rows: 200 Data size: 1600 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double) - null sort order: z - sort order: + + top n: 10 + Select Operator + expressions: (cdouble + 2.0D) (type: double) + outputColumnNames: _col0 Statistics: Num rows: 200 Data size: 1600 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: double) + null sort order: z + sort order: + + Statistics: Num rows: 200 Data size: 1600 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: diff --git ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out index cdeb909b02..6e76d7928b 100644 --- ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out @@ -1125,25 +1125,35 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterLongColNotEqualLongScalar(col 11:boolean, val 1), FilterDecimalColLessDecimalScalar(col 13:decimal(8,3), val 79.553)(children: CastLongToDecimal(col 1:smallint) -> 13:decimal(8,3)), FilterLongColNotEqualLongScalar(col 0:int, val -257)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterDoubleColGreaterDoubleColumn(col 5:double, col 14:double)(children: CastLongToDouble(col 0:tinyint) -> 14:double), FilterDoubleColGreaterEqualDoubleColumn(col 4:float, col 15:float)(children: CastLongToFloatViaLongToDouble(col 2:int) -> 15:float)), FilterExprAndExpr(children: FilterLongColLessLongColumn(col 2:bigint, col 3:bigint)(children: col 2:int), FilterLongColGreaterLongColumn(col 0:bigint, col 3:bigint)(children: col 0:tinyint)), FilterExprAndExpr(children: FilterStringColRegExpStringScalar(col 6:string, pattern a.*), FilterStringColLikeStringScalar(col 7:string, pattern %ss%))) predicate: (((cboolean2 <> 1) and (CAST( csmallint AS decimal(8,3)) < 79.553) and (UDFToInteger(ctinyint) <> -257)) or ((cdouble > UDFToDouble(ctinyint)) and (cfloat >= UDFToFloat(cint))) or ((UDFToLong(cint) < cbigint) and (UDFToLong(ctinyint) > cbigint)) or (cstring1 regexp 'a.*' and (cstring2 like '%ss%'))) (type: boolean) Statistics: Num rows: 9898 Data size: 2261486 Basic stats: COMPLETE Column stats: COMPLETE - 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), (-3728L * cbigint) (type: bigint), (- cint) (type: int), (-863.257 - CAST( cint AS decimal(10,0))) (type: decimal(14,3)), (- csmallint) (type: smallint), (csmallint - (- csmallint)) (type: smallint), ((csmallint - (- csmallint)) + (- csmallint)) (type: smallint), (UDFToDouble(cint) / UDFToDouble(cint)) (type: double), ((-863.257 - CAST( cint AS decimal(10,0))) - -26.28) (type: decimal(15,3)), (- cfloat) (type: float), (cdouble * -89010.0D) (type: double), (UDFToDouble(ctinyint) / 988888.0D) (type: double), (- ctinyint) (type: tinyint), (79.553 / CAST( ctinyint AS decimal(3,0))) (type: decimal(9,7)) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++++++++++++++++ + keys: 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), (-3728L * cbigint) (type: bigint), (- cint) (type: int), (-863.257 - CAST( cint AS decimal(10,0))) (type: decimal(14,3)), (- csmallint) (type: smallint), (csmallint - (- csmallint)) (type: smallint), ((csmallint - (- csmallint)) + (- csmallint)) (type: smallint), (UDFToDouble(cint) / UDFToDouble(cint)) (type: double), ((-863.257 - CAST( cint AS decimal(10,0))) - -26.28) (type: decimal(15,3)), (- cfloat) (type: float), (cdouble * -89010.0D) (type: double), (UDFToDouble(ctinyint) / 988888.0D) (type: double), (- ctinyint) (type: tinyint), (79.553 / CAST( ctinyint AS decimal(3,0))) (type: decimal(9,7)) + null sort order: zzzzzzzzzzzzzzzzzzzzzzz + Statistics: Num rows: 9898 Data size: 2261486 Basic stats: COMPLETE Column stats: COMPLETE + top n: 50 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 2:int, col 5:double, col 9:timestamp, col 6:string, col 11:boolean, col 0:tinyint, col 4:float, col 8:timestamp, col 1:smallint, col 3:bigint, LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 16:bigint, LongColUnaryMinus(col 2:int) -> 17:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 18:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 18:decimal(10,0)) -> 19:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 20:smallint, LongColSubtractLongColumn(col 1:smallint, col 21:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:smallint, LongColAddLongColumn(col 24:smallint, col 25:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 23:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 23:smallint) -> 24:smallint, LongColUnaryMinus(col 1:smallint) -> 25:smallint) -> 26:smallint, DoubleColDivideDoubleColumn(col 27:double, col 28:double)(children: CastLongToDouble(col 2:int) -> 27:double, CastLongToDouble(col 2:int) -> 28:double) -> 29:double, DecimalColSubtractDecimalScalar(col 31:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 30:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 30:decimal(10,0)) -> 31:decimal(14,3)) -> 32:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 33:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 34:double, DoubleColDivideDoubleScalar(col 35:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 35:double) -> 36:double, LongColUnaryMinus(col 0:tinyint) -> 37:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 38:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 38:decimal(3,0)) -> 39:decimal(9,7) native: true - projectedOutputColumnNums: [2, 5, 9, 6, 11, 0, 4, 8, 1, 3, 16, 17, 19, 20, 22, 26, 29, 32, 33, 34, 36, 37, 39] - selectExpressions: LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 16:bigint, LongColUnaryMinus(col 2:int) -> 17:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 18:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 18:decimal(10,0)) -> 19:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 20:smallint, LongColSubtractLongColumn(col 1:smallint, col 21:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 21:smallint) -> 22:smallint, LongColAddLongColumn(col 24:smallint, col 25:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 23:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 23:smallint) -> 24:smallint, LongColUnaryMinus(col 1:smallint) -> 25:smallint) -> 26:smallint, DoubleColDivideDoubleColumn(col 27:double, col 28:double)(children: CastLongToDouble(col 2:int) -> 27:double, CastLongToDouble(col 2:int) -> 28:double) -> 29:double, DecimalColSubtractDecimalScalar(col 31:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 30:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 30:decimal(10,0)) -> 31:decimal(14,3)) -> 32:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 33:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 34:double, DoubleColDivideDoubleScalar(col 35:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 35:double) -> 36:double, LongColUnaryMinus(col 0:tinyint) -> 37:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 38:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 38:decimal(3,0)) -> 39:decimal(9,7) - Statistics: Num rows: 9898 Data size: 5432062 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: double), _col2 (type: timestamp), _col3 (type: string), _col4 (type: boolean), _col5 (type: tinyint), _col6 (type: float), _col7 (type: timestamp), _col8 (type: smallint), _col9 (type: bigint), _col10 (type: bigint), _col11 (type: int), _col12 (type: decimal(14,3)), _col13 (type: smallint), _col14 (type: smallint), _col15 (type: smallint), _col16 (type: double), _col17 (type: decimal(15,3)), _col18 (type: float), _col19 (type: double), _col20 (type: double), _col21 (type: tinyint), _col22 (type: decimal(9,7)) - null sort order: zzzzzzzzzzzzzzzzzzzzzzz - sort order: +++++++++++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + 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), (-3728L * cbigint) (type: bigint), (- cint) (type: int), (-863.257 - CAST( cint AS decimal(10,0))) (type: decimal(14,3)), (- csmallint) (type: smallint), (csmallint - (- csmallint)) (type: smallint), ((csmallint - (- csmallint)) + (- csmallint)) (type: smallint), (UDFToDouble(cint) / UDFToDouble(cint)) (type: double), ((-863.257 - CAST( cint AS decimal(10,0))) - -26.28) (type: decimal(15,3)), (- cfloat) (type: float), (cdouble * -89010.0D) (type: double), (UDFToDouble(ctinyint) / 988888.0D) (type: double), (- ctinyint) (type: tinyint), (79.553 / CAST( ctinyint AS decimal(3,0))) (type: decimal(9,7)) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21, _col22 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 9898 Data size: 5432062 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [2, 5, 9, 6, 11, 0, 4, 8, 1, 3, 40, 41, 43, 44, 46, 50, 51, 54, 14, 15, 56, 57, 59] + selectExpressions: LongScalarMultiplyLongColumn(val -3728, col 3:bigint) -> 40:bigint, LongColUnaryMinus(col 2:int) -> 41:int, DecimalScalarSubtractDecimalColumn(val -863.257, col 42:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 42:decimal(10,0)) -> 43:decimal(14,3), LongColUnaryMinus(col 1:smallint) -> 44:smallint, LongColSubtractLongColumn(col 1:smallint, col 45:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 45:smallint) -> 46:smallint, LongColAddLongColumn(col 48:smallint, col 49:smallint)(children: LongColSubtractLongColumn(col 1:smallint, col 47:smallint)(children: LongColUnaryMinus(col 1:smallint) -> 47:smallint) -> 48:smallint, LongColUnaryMinus(col 1:smallint) -> 49:smallint) -> 50:smallint, DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 14:double, CastLongToDouble(col 2:int) -> 15:double) -> 51:double, DecimalColSubtractDecimalScalar(col 53:decimal(14,3), val -26.28)(children: DecimalScalarSubtractDecimalColumn(val -863.257, col 52:decimal(10,0))(children: CastLongToDecimal(col 2:int) -> 52:decimal(10,0)) -> 53:decimal(14,3)) -> 54:decimal(15,3), DoubleColUnaryMinus(col 4:float) -> 14:float, DoubleColMultiplyDoubleScalar(col 5:double, val -89010.0) -> 15:double, DoubleColDivideDoubleScalar(col 55:double, val 988888.0)(children: CastLongToDouble(col 0:tinyint) -> 55:double) -> 56:double, LongColUnaryMinus(col 0:tinyint) -> 57:tinyint, DecimalScalarDivideDecimalColumn(val 79.553, col 58:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 58:decimal(3,0)) -> 59:decimal(9,7) + Statistics: Num rows: 9898 Data size: 4905318 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: double), _col2 (type: timestamp), _col3 (type: string), _col4 (type: boolean), _col5 (type: tinyint), _col6 (type: float), _col7 (type: timestamp), _col8 (type: smallint), _col9 (type: bigint), _col10 (type: bigint), _col11 (type: int), _col12 (type: decimal(14,3)), _col13 (type: smallint), _col14 (type: smallint), _col15 (type: smallint), _col16 (type: double), _col17 (type: decimal(15,3)), _col18 (type: float), _col19 (type: double), _col20 (type: double), _col21 (type: tinyint), _col22 (type: decimal(9,7)) + null sort order: zzzzzzzzzzzzzzzzzzzzzzz + sort order: +++++++++++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 9898 Data size: 4905318 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -1171,19 +1181,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] - Statistics: Num rows: 9898 Data size: 5432062 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 9898 Data size: 4905318 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 50 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 50 Data size: 27580 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 50 Data size: 25060 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 50 Data size: 27580 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 50 Data size: 25060 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -1428,25 +1438,35 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterLongColLessLongScalar(col 10:boolean, val 0), FilterLongColEqualLongScalar(col 3:bigint, val 359), FilterExprAndExpr(children: FilterLongColLessLongScalar(col 0:int, val 197)(children: col 0:tinyint), FilterLongColEqualLongColumn(col 2:bigint, col 3:bigint)(children: col 2:int)), FilterExprAndExpr(children: FilterStringColLikeStringScalar(col 6:string, pattern %ss), FilterDoubleColLessEqualDoubleColumn(col 4:float, col 13:float)(children: CastLongToFloatViaLongToDouble(col 0:tinyint) -> 13:float))) predicate: ((cboolean1 < 0) or (cbigint = 359L) or ((UDFToInteger(ctinyint) < 197) and (UDFToLong(cint) = cbigint)) or ((cstring1 like '%ss') and (cfloat <= UDFToFloat(ctinyint)))) (type: boolean) Statistics: Num rows: 8194 Data size: 1651860 Basic stats: COMPLETE Column stats: COMPLETE - 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), (UDFToDouble(cint) / UDFToDouble(cbigint)) (type: double), (CAST( cbigint AS decimal(19,0)) % 79.553) (type: decimal(5,3)), (- (UDFToDouble(cint) / UDFToDouble(cbigint))) (type: double), (10.175 % cfloat) (type: float), (- cfloat) (type: float), (cfloat - (- cfloat)) (type: float), ((cfloat - (- cfloat)) % -6432.0) (type: float), (cdouble * UDFToDouble(csmallint)) (type: double), (- cdouble) (type: double), (- cbigint) (type: bigint), (UDFToDouble(cfloat) - (UDFToDouble(cint) / UDFToDouble(cbigint))) (type: double), (- csmallint) (type: smallint), (3569L % cbigint) (type: bigint), (359.0D - 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 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++++++++++++++++++ + keys: 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), (UDFToDouble(cint) / UDFToDouble(cbigint)) (type: double), (CAST( cbigint AS decimal(19,0)) % 79.553) (type: decimal(5,3)), (- (UDFToDouble(cint) / UDFToDouble(cbigint))) (type: double), (10.175 % cfloat) (type: float), (- cfloat) (type: float), (cfloat - (- cfloat)) (type: float), ((cfloat - (- cfloat)) % -6432.0) (type: float), (cdouble * UDFToDouble(csmallint)) (type: double), (- cdouble) (type: double), (- cbigint) (type: bigint), (UDFToDouble(cfloat) - (UDFToDouble(cint) / UDFToDouble(cbigint))) (type: double), (- csmallint) (type: smallint), (3569L % cbigint) (type: bigint), (359.0D - cdouble) (type: double), (- csmallint) (type: smallint) + null sort order: zzzzzzzzzzzzzzzzzzzzzzzzz + Statistics: Num rows: 8194 Data size: 1651860 Basic stats: COMPLETE Column stats: COMPLETE + top n: 25 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 2:int, col 3:bigint, col 6:string, col 10:boolean, col 4:float, col 5:double, col 9:timestamp, col 1:smallint, col 7:string, col 11:boolean, DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 14:double, CastLongToDouble(col 3:bigint) -> 15:double) -> 16:double, DecimalColModuloDecimalScalar(col 17:decimal(19,0), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 17:decimal(19,0)) -> 18:decimal(5,3), DoubleColUnaryMinus(col 21:double)(children: DoubleColDivideDoubleColumn(col 19:double, col 20:double)(children: CastLongToDouble(col 2:int) -> 19:double, CastLongToDouble(col 3:bigint) -> 20:double) -> 21:double) -> 22:double, DoubleScalarModuloDoubleColumn(val 10.175000190734863, col 4:float) -> 23:float, DoubleColUnaryMinus(col 4:float) -> 24:float, DoubleColSubtractDoubleColumn(col 4:float, col 25:float)(children: DoubleColUnaryMinus(col 4:float) -> 25:float) -> 26:float, DoubleColModuloDoubleScalar(col 28:float, val -6432.0)(children: DoubleColSubtractDoubleColumn(col 4:float, col 27:float)(children: DoubleColUnaryMinus(col 4:float) -> 27:float) -> 28:float) -> 29:float, DoubleColMultiplyDoubleColumn(col 5:double, col 30:double)(children: CastLongToDouble(col 1:smallint) -> 30:double) -> 31:double, DoubleColUnaryMinus(col 5:double) -> 32:double, LongColUnaryMinus(col 3:bigint) -> 33:bigint, DoubleColSubtractDoubleColumn(col 4:double, col 36:double)(children: col 4:float, DoubleColDivideDoubleColumn(col 34:double, col 35:double)(children: CastLongToDouble(col 2:int) -> 34:double, CastLongToDouble(col 3:bigint) -> 35:double) -> 36:double) -> 37:double, LongColUnaryMinus(col 1:smallint) -> 38:smallint, LongScalarModuloLongColumn(val 3569, col 3:bigint) -> 39:bigint, DoubleScalarSubtractDoubleColumn(val 359.0, col 5:double) -> 40:double, LongColUnaryMinus(col 1:smallint) -> 41:smallint native: true - projectedOutputColumnNums: [2, 3, 6, 10, 4, 5, 9, 1, 7, 11, 16, 18, 22, 23, 24, 26, 29, 31, 32, 33, 37, 38, 39, 40, 41] - selectExpressions: DoubleColDivideDoubleColumn(col 14:double, col 15:double)(children: CastLongToDouble(col 2:int) -> 14:double, CastLongToDouble(col 3:bigint) -> 15:double) -> 16:double, DecimalColModuloDecimalScalar(col 17:decimal(19,0), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 17:decimal(19,0)) -> 18:decimal(5,3), DoubleColUnaryMinus(col 21:double)(children: DoubleColDivideDoubleColumn(col 19:double, col 20:double)(children: CastLongToDouble(col 2:int) -> 19:double, CastLongToDouble(col 3:bigint) -> 20:double) -> 21:double) -> 22:double, DoubleScalarModuloDoubleColumn(val 10.175000190734863, col 4:float) -> 23:float, DoubleColUnaryMinus(col 4:float) -> 24:float, DoubleColSubtractDoubleColumn(col 4:float, col 25:float)(children: DoubleColUnaryMinus(col 4:float) -> 25:float) -> 26:float, DoubleColModuloDoubleScalar(col 28:float, val -6432.0)(children: DoubleColSubtractDoubleColumn(col 4:float, col 27:float)(children: DoubleColUnaryMinus(col 4:float) -> 27:float) -> 28:float) -> 29:float, DoubleColMultiplyDoubleColumn(col 5:double, col 30:double)(children: CastLongToDouble(col 1:smallint) -> 30:double) -> 31:double, DoubleColUnaryMinus(col 5:double) -> 32:double, LongColUnaryMinus(col 3:bigint) -> 33:bigint, DoubleColSubtractDoubleColumn(col 4:double, col 36:double)(children: col 4:float, DoubleColDivideDoubleColumn(col 34:double, col 35:double)(children: CastLongToDouble(col 2:int) -> 34:double, CastLongToDouble(col 3:bigint) -> 35:double) -> 36:double) -> 37:double, LongColUnaryMinus(col 1:smallint) -> 38:smallint, LongScalarModuloLongColumn(val 3569, col 3:bigint) -> 39:bigint, DoubleScalarSubtractDoubleColumn(val 359.0, col 5:double) -> 40:double, LongColUnaryMinus(col 1:smallint) -> 41:smallint - Statistics: Num rows: 8194 Data size: 3266188 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: boolean), _col4 (type: float), _col5 (type: double), _col6 (type: timestamp), _col7 (type: smallint), _col8 (type: string), _col9 (type: boolean), _col10 (type: double), _col11 (type: decimal(5,3)), _col12 (type: double), _col13 (type: float), _col14 (type: float), _col15 (type: float), _col16 (type: float), _col17 (type: double), _col18 (type: double), _col19 (type: bigint), _col20 (type: double), _col21 (type: smallint), _col22 (type: bigint), _col23 (type: double), _col24 (type: smallint) - null sort order: zzzzzzzzzzzzzzzzzzzzzzzzz - sort order: +++++++++++++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + 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), (UDFToDouble(cint) / UDFToDouble(cbigint)) (type: double), (CAST( cbigint AS decimal(19,0)) % 79.553) (type: decimal(5,3)), (- (UDFToDouble(cint) / UDFToDouble(cbigint))) (type: double), (10.175 % cfloat) (type: float), (- cfloat) (type: float), (cfloat - (- cfloat)) (type: float), ((cfloat - (- cfloat)) % -6432.0) (type: float), (cdouble * UDFToDouble(csmallint)) (type: double), (- cdouble) (type: double), (- cbigint) (type: bigint), (UDFToDouble(cfloat) - (UDFToDouble(cint) / UDFToDouble(cbigint))) (type: double), (- csmallint) (type: smallint), (3569L % cbigint) (type: bigint), (359.0D - 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 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 8194 Data size: 3266188 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + projectedOutputColumnNums: [2, 3, 6, 10, 4, 5, 9, 1, 7, 11, 43, 45, 13, 48, 49, 51, 54, 56, 57, 58, 62, 63, 64, 65, 66] + selectExpressions: DoubleColDivideDoubleColumn(col 13:double, col 42:double)(children: CastLongToDouble(col 2:int) -> 13:double, CastLongToDouble(col 3:bigint) -> 42:double) -> 43:double, DecimalColModuloDecimalScalar(col 44:decimal(19,0), val 79.553)(children: CastLongToDecimal(col 3:bigint) -> 44:decimal(19,0)) -> 45:decimal(5,3), DoubleColUnaryMinus(col 47:double)(children: DoubleColDivideDoubleColumn(col 13:double, col 46:double)(children: CastLongToDouble(col 2:int) -> 13:double, CastLongToDouble(col 3:bigint) -> 46:double) -> 47:double) -> 13:double, DoubleScalarModuloDoubleColumn(val 10.175000190734863, col 4:float) -> 48:float, DoubleColUnaryMinus(col 4:float) -> 49:float, DoubleColSubtractDoubleColumn(col 4:float, col 50:float)(children: DoubleColUnaryMinus(col 4:float) -> 50:float) -> 51:float, DoubleColModuloDoubleScalar(col 53:float, val -6432.0)(children: DoubleColSubtractDoubleColumn(col 4:float, col 52:float)(children: DoubleColUnaryMinus(col 4:float) -> 52:float) -> 53:float) -> 54:float, DoubleColMultiplyDoubleColumn(col 5:double, col 55:double)(children: CastLongToDouble(col 1:smallint) -> 55:double) -> 56:double, DoubleColUnaryMinus(col 5:double) -> 57:double, LongColUnaryMinus(col 3:bigint) -> 58:bigint, DoubleColSubtractDoubleColumn(col 4:double, col 61:double)(children: col 4:float, DoubleColDivideDoubleColumn(col 59:double, col 60:double)(children: CastLongToDouble(col 2:int) -> 59:double, CastLongToDouble(col 3:bigint) -> 60:double) -> 61:double) -> 62:double, LongColUnaryMinus(col 1:smallint) -> 63:smallint, LongScalarModuloLongColumn(val 3569, col 3:bigint) -> 64:bigint, DoubleScalarSubtractDoubleColumn(val 359.0, col 5:double) -> 65:double, LongColUnaryMinus(col 1:smallint) -> 66:smallint + Statistics: Num rows: 8194 Data size: 2713706 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: bigint), _col2 (type: string), _col3 (type: boolean), _col4 (type: float), _col5 (type: double), _col6 (type: timestamp), _col7 (type: smallint), _col8 (type: string), _col9 (type: boolean), _col10 (type: double), _col11 (type: decimal(5,3)), _col12 (type: double), _col13 (type: float), _col14 (type: float), _col15 (type: float), _col16 (type: float), _col17 (type: double), _col18 (type: double), _col19 (type: bigint), _col20 (type: double), _col21 (type: smallint), _col22 (type: bigint), _col23 (type: double), _col24 (type: smallint) + null sort order: zzzzzzzzzzzzzzzzzzzzzzzzz + sort order: +++++++++++++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 8194 Data size: 2713706 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -1474,19 +1494,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 21] - Statistics: Num rows: 8194 Data size: 3266188 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 8194 Data size: 2713706 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 25 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 25 Data size: 10320 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 25 Data size: 8458 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 25 Data size: 10320 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 25 Data size: 8458 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -1680,26 +1700,36 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 13:float, col 4:float)(children: CastLongToFloatViaLongToDouble(col 3:bigint) -> 13:float), FilterDecimalColGreaterEqualDecimalScalar(col 14:decimal(7,2), val -26.28)(children: CastLongToDecimal(col 1:smallint) -> 14:decimal(7,2))), FilterExprAndExpr(children: FilterDoubleColLessEqualDoubleColumn(col 5:double, col 15:double)(children: CastLongToDouble(col 3:bigint) -> 15:double), FilterStringGroupColGreaterEqualStringScalar(col 6:string, val ss), FilterDoubleColNotEqualDoubleColumn(col 16:double, col 5:double)(children: CastLongToDouble(col 2:int) -> 16:double)), FilterLongColEqualLongScalar(col 0:int, val -89010)(children: col 0:tinyint), FilterExprAndExpr(children: FilterDecimalColGreaterDecimalScalar(col 17:decimal(7,2), val -26.28)(children: CastLongToDecimal(col 1:smallint) -> 17:decimal(7,2)), FilterStringColLikeStringScalar(col 7:string, pattern ss))) predicate: (((UDFToFloat(cbigint) <= cfloat) and (CAST( csmallint AS decimal(7,2)) >= -26.28)) or ((cdouble <= UDFToDouble(cbigint)) and (cstring1 >= 'ss') and (UDFToDouble(cint) <> cdouble)) or (UDFToInteger(ctinyint) = -89010) or ((CAST( csmallint AS decimal(7,2)) > -26.28) and (cstring2 like 'ss'))) (type: boolean) Statistics: Num rows: 10922 Data size: 2201730 Basic stats: COMPLETE Column stats: COMPLETE - 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 + UDFToInteger(csmallint)) (type: int), (cbigint - UDFToLong(ctinyint)) (type: bigint), (- cbigint) (type: bigint), (- cfloat) (type: float), ((cbigint - UDFToLong(ctinyint)) + cbigint) (type: bigint), (cdouble / cdouble) (type: double), (- cdouble) (type: double), (UDFToLong((cint + UDFToInteger(csmallint))) * (- cbigint)) (type: bigint), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (-1.389 / CAST( ctinyint AS decimal(3,0))) (type: decimal(8,7)), (UDFToDouble(cbigint) % cdouble) (type: double), (- csmallint) (type: smallint), (UDFToInteger(csmallint) + (cint + UDFToInteger(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 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++++++++++++++ + keys: cboolean1 (type: boolean), cstring1 (type: string), ctimestamp2 (type: timestamp), cfloat (type: float), cbigint (type: bigint), cdouble (type: double), cint (type: int), csmallint (type: smallint), (cint + UDFToInteger(csmallint)) (type: int), (cbigint - UDFToLong(ctinyint)) (type: bigint), (- cbigint) (type: bigint), (- cfloat) (type: float), ((cbigint - UDFToLong(ctinyint)) + cbigint) (type: bigint), (cdouble / cdouble) (type: double), (- cdouble) (type: double), (UDFToLong((cint + UDFToInteger(csmallint))) * (- cbigint)) (type: bigint), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (-1.389 / CAST( ctinyint AS decimal(3,0))) (type: decimal(8,7)), (UDFToDouble(cbigint) % cdouble) (type: double), (- csmallint) (type: smallint), (UDFToInteger(csmallint) + (cint + UDFToInteger(csmallint))) (type: int) + null sort order: zzzzzzzzzzzzzzzzzzzzz + Statistics: Num rows: 10922 Data size: 2201730 Basic stats: COMPLETE Column stats: COMPLETE + top n: 75 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 10:boolean, col 6:string, col 9:timestamp, col 4:float, col 3:bigint, col 5:double, col 2:int, col 1:smallint, LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 18:int, LongColSubtractLongColumn(col 3:bigint, col 0:bigint)(children: col 0:tinyint) -> 19:bigint, LongColUnaryMinus(col 3:bigint) -> 20:bigint, DoubleColUnaryMinus(col 4:float) -> 21:float, LongColAddLongColumn(col 22:bigint, col 3:bigint)(children: LongColSubtractLongColumn(col 3:bigint, col 0:bigint)(children: col 0:tinyint) -> 22:bigint) -> 23:bigint, DoubleColDivideDoubleColumn(col 5:double, col 5:double) -> 24:double, DoubleColUnaryMinus(col 5:double) -> 25:double, LongColMultiplyLongColumn(col 26:bigint, col 27:bigint)(children: LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 26:int, LongColUnaryMinus(col 3:bigint) -> 27:bigint) -> 28:bigint, DoubleColAddDoubleColumn(col 29:double, col 30:double)(children: DoubleColUnaryMinus(col 5:double) -> 29:double, CastLongToDouble(col 3:bigint) -> 30:double) -> 31:double, DecimalScalarDivideDecimalColumn(val -1.389, col 32:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 32:decimal(3,0)) -> 33:decimal(8,7), DoubleColModuloDoubleColumn(col 34:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 34:double) -> 35:double, LongColUnaryMinus(col 1:smallint) -> 36:smallint, LongColAddLongColumn(col 1:int, col 37:int)(children: col 1:smallint, LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 37:int) -> 38:int native: true - projectedOutputColumnNums: [2, 6, 11, 9, 5, 4, 3, 1, 10, 18, 19, 20, 21, 23, 24, 25, 28, 31, 33, 35, 36, 38] - selectExpressions: LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 18:int, LongColSubtractLongColumn(col 3:bigint, col 0:bigint)(children: col 0:tinyint) -> 19:bigint, LongColUnaryMinus(col 3:bigint) -> 20:bigint, DoubleColUnaryMinus(col 4:float) -> 21:float, LongColAddLongColumn(col 22:bigint, col 3:bigint)(children: LongColSubtractLongColumn(col 3:bigint, col 0:bigint)(children: col 0:tinyint) -> 22:bigint) -> 23:bigint, DoubleColDivideDoubleColumn(col 5:double, col 5:double) -> 24:double, DoubleColUnaryMinus(col 5:double) -> 25:double, LongColMultiplyLongColumn(col 26:bigint, col 27:bigint)(children: LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 26:int, LongColUnaryMinus(col 3:bigint) -> 27:bigint) -> 28:bigint, DoubleColAddDoubleColumn(col 29:double, col 30:double)(children: DoubleColUnaryMinus(col 5:double) -> 29:double, CastLongToDouble(col 3:bigint) -> 30:double) -> 31:double, DecimalScalarDivideDecimalColumn(val -1.389, col 32:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 32:decimal(3,0)) -> 33:decimal(8,7), DoubleColModuloDoubleColumn(col 34:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 34:double) -> 35:double, LongColUnaryMinus(col 1:smallint) -> 36:smallint, LongColAddLongColumn(col 1:int, col 37:int)(children: col 1:smallint, LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 37:int) -> 38:int - Statistics: Num rows: 10922 Data size: 3483354 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col8 (type: boolean), _col1 (type: string), _col3 (type: timestamp), _col5 (type: float), _col6 (type: bigint), _col4 (type: double), _col0 (type: int), _col7 (type: smallint), _col9 (type: int), _col10 (type: bigint), _col11 (type: bigint), _col12 (type: float), _col13 (type: bigint), _col14 (type: double), _col15 (type: double), _col16 (type: bigint), _col17 (type: double), _col18 (type: decimal(8,7)), _col19 (type: double), _col20 (type: smallint), _col21 (type: int) - null sort order: zzzzzzzzzzzzzzzzzzzzz - sort order: +++++++++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + 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 + UDFToInteger(csmallint)) (type: int), (cbigint - UDFToLong(ctinyint)) (type: bigint), (- cbigint) (type: bigint), (- cfloat) (type: float), ((cbigint - UDFToLong(ctinyint)) + cbigint) (type: bigint), (cdouble / cdouble) (type: double), (- cdouble) (type: double), (UDFToLong((cint + UDFToInteger(csmallint))) * (- cbigint)) (type: bigint), ((- cdouble) + UDFToDouble(cbigint)) (type: double), (-1.389 / CAST( ctinyint AS decimal(3,0))) (type: decimal(8,7)), (UDFToDouble(cbigint) % cdouble) (type: double), (- csmallint) (type: smallint), (UDFToInteger(csmallint) + (cint + UDFToInteger(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 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 10922 Data size: 3483354 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col2 (type: boolean) + projectedOutputColumnNums: [2, 6, 11, 9, 5, 4, 3, 1, 10, 39, 40, 41, 13, 43, 15, 16, 46, 49, 51, 53, 54, 56] + selectExpressions: LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 39:int, LongColSubtractLongColumn(col 3:bigint, col 0:bigint)(children: col 0:tinyint) -> 40:bigint, LongColUnaryMinus(col 3:bigint) -> 41:bigint, DoubleColUnaryMinus(col 4:float) -> 13:float, LongColAddLongColumn(col 42:bigint, col 3:bigint)(children: LongColSubtractLongColumn(col 3:bigint, col 0:bigint)(children: col 0:tinyint) -> 42:bigint) -> 43:bigint, DoubleColDivideDoubleColumn(col 5:double, col 5:double) -> 15:double, DoubleColUnaryMinus(col 5:double) -> 16:double, LongColMultiplyLongColumn(col 44:bigint, col 45:bigint)(children: LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 44:int, LongColUnaryMinus(col 3:bigint) -> 45:bigint) -> 46:bigint, DoubleColAddDoubleColumn(col 47:double, col 48:double)(children: DoubleColUnaryMinus(col 5:double) -> 47:double, CastLongToDouble(col 3:bigint) -> 48:double) -> 49:double, DecimalScalarDivideDecimalColumn(val -1.389, col 50:decimal(3,0))(children: CastLongToDecimal(col 0:tinyint) -> 50:decimal(3,0)) -> 51:decimal(8,7), DoubleColModuloDoubleColumn(col 52:double, col 5:double)(children: CastLongToDouble(col 3:bigint) -> 52:double) -> 53:double, LongColUnaryMinus(col 1:smallint) -> 54:smallint, LongColAddLongColumn(col 1:int, col 55:int)(children: col 1:smallint, LongColAddLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 55:int) -> 56:int + Statistics: Num rows: 10922 Data size: 3012774 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col8 (type: boolean), _col1 (type: string), _col3 (type: timestamp), _col5 (type: float), _col6 (type: bigint), _col4 (type: double), _col0 (type: int), _col7 (type: smallint), _col9 (type: int), _col10 (type: bigint), _col11 (type: bigint), _col12 (type: float), _col13 (type: bigint), _col14 (type: double), _col15 (type: double), _col16 (type: bigint), _col17 (type: double), _col18 (type: decimal(8,7)), _col19 (type: double), _col20 (type: smallint), _col21 (type: int) + null sort order: zzzzzzzzzzzzzzzzzzzzz + sort order: +++++++++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 10922 Data size: 3012774 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col2 (type: boolean) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -1727,19 +1757,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [6, 1, 21, 2, 5, 3, 4, 7, 0, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] - Statistics: Num rows: 10922 Data size: 3483354 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 10922 Data size: 3012774 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 75 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 75 Data size: 24090 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 75 Data size: 20860 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 75 Data size: 24090 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 75 Data size: 20860 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -1990,26 +2020,36 @@ STAGE PLANS: predicateExpression: FilterExprOrExpr(children: FilterExprAndExpr(children: FilterDoubleColGreaterEqualDoubleColumn(col 5:double, col 4:double)(children: col 4:float), FilterStringGroupColLessEqualStringScalar(col 7:string, val a)), FilterExprAndExpr(children: FilterDecimalColLessEqualDecimalScalar(col 13:decimal(13,3), val -1.389)(children: CastLongToDecimal(col 2:int) -> 13:decimal(13,3)), FilterLongColLessLongColumn(col 1:smallint, col 0:smallint)(children: col 0:tinyint), FilterLongColLessLongScalar(col 1:int, val -6432)(children: col 1:smallint)), FilterExprAndExpr(children: FilterStringColLikeStringScalar(col 6:string, pattern ss%), FilterDecimalColLessDecimalScalar(col 14:decimal(22,3), val 10.175)(children: CastLongToDecimal(col 3:bigint) -> 14:decimal(22,3)))) predicate: (((cdouble >= UDFToDouble(cfloat)) and (cstring2 <= 'a')) or ((CAST( cint AS decimal(13,3)) <= -1.389) and (csmallint < UDFToShort(ctinyint)) and (UDFToInteger(csmallint) < -6432)) or ((cstring1 like 'ss%') and (CAST( cbigint AS decimal(22,3)) < 10.175))) (type: boolean) Statistics: Num rows: 3868 Data size: 756762 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: ctimestamp1 (type: timestamp), cstring2 (type: string), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), csmallint (type: smallint), (UDFToDouble(cbigint) / 3569.0D) (type: double), (-257 - UDFToInteger(csmallint)) (type: int), (-6432.0 * cfloat) (type: float), (- cdouble) (type: double), (cdouble * 10.175D) (type: double), (UDFToDouble((-6432.0 * cfloat)) / UDFToDouble(cfloat)) (type: double), (- cfloat) (type: float), (cint % UDFToInteger(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 - Select Vectorization: - className: VectorSelectOperator + Top N Key Operator + sort order: +++++++++++++++ + keys: csmallint (type: smallint), cstring2 (type: string), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), (UDFToDouble(cbigint) / 3569.0D) (type: double), (-257 - UDFToInteger(csmallint)) (type: int), (-6432.0 * cfloat) (type: float), (- cdouble) (type: double), (cdouble * 10.175D) (type: double), (UDFToDouble((-6432.0 * cfloat)) / UDFToDouble(cfloat)) (type: double), (- cfloat) (type: float), (cint % UDFToInteger(csmallint)) (type: int), (- cdouble) (type: double), (cdouble * (- cdouble)) (type: double) + null sort order: zzzzzzzzzzzzzzz + Statistics: Num rows: 3868 Data size: 756762 Basic stats: COMPLETE Column stats: COMPLETE + top n: 45 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 1:smallint, col 7:string, col 5:double, col 4:float, col 3:bigint, DoubleColDivideDoubleScalar(col 15:double, val 3569.0)(children: CastLongToDouble(col 3:bigint) -> 15:double) -> 16:double, LongScalarSubtractLongColumn(val -257, col 1:int)(children: col 1:smallint) -> 17:int, DoubleScalarMultiplyDoubleColumn(val -6432.0, col 4:float) -> 18:float, DoubleColUnaryMinus(col 5:double) -> 19:double, DoubleColMultiplyDoubleScalar(col 5:double, val 10.175) -> 20:double, DoubleColDivideDoubleColumn(col 21:double, col 4:double)(children: DoubleScalarMultiplyDoubleColumn(val -6432.0, col 4:float) -> 21:float, col 4:float) -> 22:double, DoubleColUnaryMinus(col 4:float) -> 23:float, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 24:int, DoubleColUnaryMinus(col 5:double) -> 25:double, DoubleColMultiplyDoubleColumn(col 5:double, col 26:double)(children: DoubleColUnaryMinus(col 5:double) -> 26:double) -> 27:double native: true - projectedOutputColumnNums: [8, 7, 5, 4, 3, 1, 16, 17, 18, 19, 20, 22, 23, 24, 25, 27] - selectExpressions: DoubleColDivideDoubleScalar(col 15:double, val 3569.0)(children: CastLongToDouble(col 3:bigint) -> 15:double) -> 16:double, LongScalarSubtractLongColumn(val -257, col 1:int)(children: col 1:smallint) -> 17:int, DoubleScalarMultiplyDoubleColumn(val -6432.0, col 4:float) -> 18:float, DoubleColUnaryMinus(col 5:double) -> 19:double, DoubleColMultiplyDoubleScalar(col 5:double, val 10.175) -> 20:double, DoubleColDivideDoubleColumn(col 21:double, col 4:double)(children: DoubleScalarMultiplyDoubleColumn(val -6432.0, col 4:float) -> 21:float, col 4:float) -> 22:double, DoubleColUnaryMinus(col 4:float) -> 23:float, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 24:int, DoubleColUnaryMinus(col 5:double) -> 25:double, DoubleColMultiplyDoubleColumn(col 5:double, col 26:double)(children: DoubleColUnaryMinus(col 5:double) -> 26:double) -> 27:double - Statistics: Num rows: 3868 Data size: 709644 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col5 (type: smallint), _col1 (type: string), _col2 (type: double), _col3 (type: float), _col4 (type: bigint), _col6 (type: double), _col7 (type: int), _col8 (type: float), _col9 (type: double), _col10 (type: double), _col11 (type: double), _col12 (type: float), _col13 (type: int), _col14 (type: double), _col15 (type: double) - null sort order: zzzzzzzzzzzzzzz - sort order: +++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + Select Operator + expressions: ctimestamp1 (type: timestamp), cstring2 (type: string), cdouble (type: double), cfloat (type: float), cbigint (type: bigint), csmallint (type: smallint), (UDFToDouble(cbigint) / 3569.0D) (type: double), (-257 - UDFToInteger(csmallint)) (type: int), (-6432.0 * cfloat) (type: float), (- cdouble) (type: double), (cdouble * 10.175D) (type: double), (UDFToDouble((-6432.0 * cfloat)) / UDFToDouble(cfloat)) (type: double), (- cfloat) (type: float), (cint % UDFToInteger(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 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 3868 Data size: 709644 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col0 (type: timestamp) + projectedOutputColumnNums: [8, 7, 5, 4, 3, 1, 29, 30, 31, 32, 33, 35, 36, 37, 38, 40] + selectExpressions: DoubleColDivideDoubleScalar(col 28:double, val 3569.0)(children: CastLongToDouble(col 3:bigint) -> 28:double) -> 29:double, LongScalarSubtractLongColumn(val -257, col 1:int)(children: col 1:smallint) -> 30:int, DoubleScalarMultiplyDoubleColumn(val -6432.0, col 4:float) -> 31:float, DoubleColUnaryMinus(col 5:double) -> 32:double, DoubleColMultiplyDoubleScalar(col 5:double, val 10.175) -> 33:double, DoubleColDivideDoubleColumn(col 34:double, col 4:double)(children: DoubleScalarMultiplyDoubleColumn(val -6432.0, col 4:float) -> 34:float, col 4:float) -> 35:double, DoubleColUnaryMinus(col 4:float) -> 36:float, LongColModuloLongColumn(col 2:int, col 1:int)(children: col 1:smallint) -> 37:int, DoubleColUnaryMinus(col 5:double) -> 38:double, DoubleColMultiplyDoubleColumn(col 5:double, col 39:double)(children: DoubleColUnaryMinus(col 5:double) -> 39:double) -> 40:double + Statistics: Num rows: 3868 Data size: 552696 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col5 (type: smallint), _col1 (type: string), _col2 (type: double), _col3 (type: float), _col4 (type: bigint), _col6 (type: double), _col7 (type: int), _col8 (type: float), _col9 (type: double), _col10 (type: double), _col11 (type: double), _col12 (type: float), _col13 (type: int), _col14 (type: double), _col15 (type: double) + null sort order: zzzzzzzzzzzzzzz + sort order: +++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 3868 Data size: 552696 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col0 (type: timestamp) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -2037,19 +2077,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [15, 1, 2, 3, 4, 0, 5, 6, 7, 8, 9, 10, 11, 12, 8, 14] - Statistics: Num rows: 3868 Data size: 709644 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 3868 Data size: 552696 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 45 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 45 Data size: 8480 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 45 Data size: 6560 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 45 Data size: 8480 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 45 Data size: 6560 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -2297,39 +2337,59 @@ STAGE PLANS: usesVectorUDFAdaptor: false vectorized: true Reduce Operator Tree: - Group By Operator - aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), sum(VALUE._col3), sum(VALUE._col4), sum(VALUE._col5), count(VALUE._col6), count(VALUE._col7) - Group By Vectorization: - aggregators: VectorUDAFSumDouble(col 1:double) -> double, VectorUDAFSumDouble(col 2:double) -> double, VectorUDAFCountMerge(col 3:bigint) -> bigint, VectorUDAFSumLong(col 4:bigint) -> bigint, VectorUDAFSumDouble(col 5:double) -> double, VectorUDAFSumDouble(col 6:double) -> double, VectorUDAFCountMerge(col 7:bigint) -> bigint, VectorUDAFCountMerge(col 8:bigint) -> bigint - className: VectorGroupByOperator - groupByMode: MERGEPARTIAL - keyExpressions: col 0:smallint - native: false - vectorProcessingMode: MERGE_PARTIAL - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7] + Top N Key Operator + sort order: + keys: KEY._col0 (type: smallint) - mode: mergepartial - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + null sort order: z Statistics: Num rows: 227 Data size: 15212 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: smallint), (UDFToInteger(_col0) % -75) (type: int), power(((_col1 - ((_col2 * _col2) / _col3)) / CASE WHEN ((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END), 0.5) (type: double), (-1.389 / CAST( _col0 AS decimal(5,0))) (type: decimal(10,9)), _col4 (type: bigint), (UDFToDouble((UDFToInteger(_col0) % -75)) / UDFToDouble(_col4)) (type: double), (- (UDFToInteger(_col0) % -75)) (type: int), ((_col5 - ((_col6 * _col6) / _col7)) / _col7) (type: double), (- (- (UDFToInteger(_col0) % -75))) (type: int), _col8 (type: bigint), (_col8 - -89010L) (type: bigint) - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 9, 17, 19, 4, 23, 25, 29, 32, 8, 33] - selectExpressions: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 9:int, FuncPowerDoubleToDouble(col 16:double)(children: DoubleColDivideLongColumn(col 12:double, col 15:bigint)(children: DoubleColSubtractDoubleColumn(col 1:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 3:bigint)(children: DoubleColMultiplyDoubleColumn(col 2:double, col 2:double) -> 10:double) -> 11:double) -> 12:double, IfExprNullCondExpr(col 13:boolean, null, col 14:bigint)(children: LongColEqualLongScalar(col 3:bigint, val 1) -> 13:boolean, LongColSubtractLongScalar(col 3:bigint, val 1) -> 14:bigint) -> 15:bigint) -> 16:double) -> 17:double, DecimalScalarDivideDecimalColumn(val -1.389, col 18:decimal(5,0))(children: CastLongToDecimal(col 0:smallint) -> 18:decimal(5,0)) -> 19:decimal(10,9), DoubleColDivideDoubleColumn(col 21:double, col 22:double)(children: CastLongToDouble(col 20:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 20:int) -> 21:double, CastLongToDouble(col 4:bigint) -> 22:double) -> 23:double, LongColUnaryMinus(col 24:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 24:int) -> 25:int, DoubleColDivideLongColumn(col 28:double, col 7:bigint)(children: DoubleColSubtractDoubleColumn(col 5:double, col 27:double)(children: DoubleColDivideLongColumn(col 26:double, col 7:bigint)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 6:double) -> 26:double) -> 27:double) -> 28:double) -> 29:double, LongColUnaryMinus(col 31:int)(children: LongColUnaryMinus(col 30:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 30:int) -> 31:int) -> 32:int, LongColSubtractLongScalar(col 8:bigint, val -89010) -> 33:bigint - Statistics: Num rows: 227 Data size: 39728 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: smallint), _col1 (type: int), _col2 (type: double), _col3 (type: decimal(10,9)), _col4 (type: bigint), _col5 (type: double), _col6 (type: int), _col7 (type: double), _col8 (type: int), _col9 (type: bigint), _col10 (type: bigint) - null sort order: zzzzzzzzzzz + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:smallint + native: true + Group By Operator + aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), sum(VALUE._col3), sum(VALUE._col4), sum(VALUE._col5), count(VALUE._col6), count(VALUE._col7) + Group By Vectorization: + aggregators: VectorUDAFSumDouble(col 1:double) -> double, VectorUDAFSumDouble(col 2:double) -> double, VectorUDAFCountMerge(col 3:bigint) -> bigint, VectorUDAFSumLong(col 4:bigint) -> bigint, VectorUDAFSumDouble(col 5:double) -> double, VectorUDAFSumDouble(col 6:double) -> double, VectorUDAFCountMerge(col 7:bigint) -> bigint, VectorUDAFCountMerge(col 8:bigint) -> bigint + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + keyExpressions: col 0:smallint + native: false + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7] + keys: KEY._col0 (type: smallint) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Statistics: Num rows: 227 Data size: 14984 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator sort order: +++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + keys: _col0 (type: smallint), (UDFToInteger(_col0) % -75) (type: int), power(((_col1 - ((_col2 * _col2) / _col3)) / CASE WHEN ((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END), 0.5) (type: double), (-1.389 / CAST( _col0 AS decimal(5,0))) (type: decimal(10,9)), _col4 (type: bigint), (UDFToDouble((UDFToInteger(_col0) % -75)) / UDFToDouble(_col4)) (type: double), (- (UDFToInteger(_col0) % -75)) (type: int), ((_col5 - ((_col6 * _col6) / _col7)) / _col7) (type: double), (- (- (UDFToInteger(_col0) % -75))) (type: int), _col8 (type: bigint), (_col8 - -89010L) (type: bigint) + null sort order: zzzzzzzzzzz + Statistics: Num rows: 227 Data size: 14984 Basic stats: COMPLETE Column stats: COMPLETE + top n: 20 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:smallint, LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 9:int, FuncPowerDoubleToDouble(col 16:double)(children: DoubleColDivideLongColumn(col 12:double, col 15:bigint)(children: DoubleColSubtractDoubleColumn(col 1:double, col 11:double)(children: DoubleColDivideLongColumn(col 10:double, col 3:bigint)(children: DoubleColMultiplyDoubleColumn(col 2:double, col 2:double) -> 10:double) -> 11:double) -> 12:double, IfExprNullCondExpr(col 13:boolean, null, col 14:bigint)(children: LongColEqualLongScalar(col 3:bigint, val 1) -> 13:boolean, LongColSubtractLongScalar(col 3:bigint, val 1) -> 14:bigint) -> 15:bigint) -> 16:double) -> 17:double, DecimalScalarDivideDecimalColumn(val -1.389, col 18:decimal(5,0))(children: CastLongToDecimal(col 0:smallint) -> 18:decimal(5,0)) -> 19:decimal(10,9), col 4:bigint, DoubleColDivideDoubleColumn(col 21:double, col 22:double)(children: CastLongToDouble(col 20:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 20:int) -> 21:double, CastLongToDouble(col 4:bigint) -> 22:double) -> 23:double, LongColUnaryMinus(col 24:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 24:int) -> 25:int, DoubleColDivideLongColumn(col 28:double, col 7:bigint)(children: DoubleColSubtractDoubleColumn(col 5:double, col 27:double)(children: DoubleColDivideLongColumn(col 26:double, col 7:bigint)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 6:double) -> 26:double) -> 27:double) -> 28:double) -> 29:double, LongColUnaryMinus(col 31:int)(children: LongColUnaryMinus(col 30:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 30:int) -> 31:int) -> 32:int, col 8:bigint, LongColSubtractLongScalar(col 8:bigint, val -89010) -> 33:bigint native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 227 Data size: 39728 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Select Operator + expressions: _col0 (type: smallint), (UDFToInteger(_col0) % -75) (type: int), power(((_col1 - ((_col2 * _col2) / _col3)) / CASE WHEN ((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END), 0.5) (type: double), (-1.389 / CAST( _col0 AS decimal(5,0))) (type: decimal(10,9)), _col4 (type: bigint), (UDFToDouble((UDFToInteger(_col0) % -75)) / UDFToDouble(_col4)) (type: double), (- (UDFToInteger(_col0) % -75)) (type: int), ((_col5 - ((_col6 * _col6) / _col7)) / _col7) (type: double), (- (- (UDFToInteger(_col0) % -75))) (type: int), _col8 (type: bigint), (_col8 - -89010L) (type: bigint) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [0, 34, 42, 44, 4, 48, 50, 54, 57, 8, 58] + selectExpressions: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 34:int, FuncPowerDoubleToDouble(col 41:double)(children: DoubleColDivideLongColumn(col 37:double, col 40:bigint)(children: DoubleColSubtractDoubleColumn(col 1:double, col 36:double)(children: DoubleColDivideLongColumn(col 35:double, col 3:bigint)(children: DoubleColMultiplyDoubleColumn(col 2:double, col 2:double) -> 35:double) -> 36:double) -> 37:double, IfExprNullCondExpr(col 38:boolean, null, col 39:bigint)(children: LongColEqualLongScalar(col 3:bigint, val 1) -> 38:boolean, LongColSubtractLongScalar(col 3:bigint, val 1) -> 39:bigint) -> 40:bigint) -> 41:double) -> 42:double, DecimalScalarDivideDecimalColumn(val -1.389, col 43:decimal(5,0))(children: CastLongToDecimal(col 0:smallint) -> 43:decimal(5,0)) -> 44:decimal(10,9), DoubleColDivideDoubleColumn(col 46:double, col 47:double)(children: CastLongToDouble(col 45:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 45:int) -> 46:double, CastLongToDouble(col 4:bigint) -> 47:double) -> 48:double, LongColUnaryMinus(col 49:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 49:int) -> 50:int, DoubleColDivideLongColumn(col 53:double, col 7:bigint)(children: DoubleColSubtractDoubleColumn(col 5:double, col 52:double)(children: DoubleColDivideLongColumn(col 51:double, col 7:bigint)(children: DoubleColMultiplyDoubleColumn(col 6:double, col 6:double) -> 51:double) -> 52:double) -> 53:double) -> 54:double, LongColUnaryMinus(col 56:int)(children: LongColUnaryMinus(col 55:int)(children: LongColModuloLongScalar(col 0:int, val -75)(children: col 0:smallint) -> 55:int) -> 56:int) -> 57:int, LongColSubtractLongScalar(col 8:bigint, val -89010) -> 58:bigint + Statistics: Num rows: 227 Data size: 39044 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: smallint), _col1 (type: int), _col2 (type: double), _col3 (type: decimal(10,9)), _col4 (type: bigint), _col5 (type: double), _col6 (type: int), _col7 (type: double), _col8 (type: int), _col9 (type: bigint), _col10 (type: bigint) + null sort order: zzzzzzzzzzz + sort order: +++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 227 Data size: 39044 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -2346,19 +2406,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] - Statistics: Num rows: 227 Data size: 39728 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 227 Data size: 39044 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 3504 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 3444 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 3504 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 20 Data size: 3444 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -2911,39 +2971,59 @@ STAGE PLANS: usesVectorUDFAdaptor: false vectorized: true Reduce Operator Tree: - Group By Operator - aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), count(VALUE._col5), min(VALUE._col6), sum(VALUE._col7), sum(VALUE._col8), sum(VALUE._col9), sum(VALUE._col10), count(VALUE._col11), sum(VALUE._col12), sum(VALUE._col13), min(VALUE._col14), sum(VALUE._col15), sum(VALUE._col16), count(VALUE._col17) - Group By Vectorization: - aggregators: VectorUDAFSumDouble(col 2:double) -> double, VectorUDAFSumDouble(col 3:double) -> double, VectorUDAFCountMerge(col 4:bigint) -> bigint, VectorUDAFSumLong(col 5:bigint) -> bigint, VectorUDAFCountMerge(col 6:bigint) -> bigint, VectorUDAFCountMerge(col 7:bigint) -> bigint, VectorUDAFMinLong(col 8:tinyint) -> tinyint, VectorUDAFSumDouble(col 9:double) -> double, VectorUDAFSumDouble(col 10:double) -> double, VectorUDAFSumDouble(col 11:double) -> double, VectorUDAFSumDouble(col 12:double) -> double, VectorUDAFCountMerge(col 13:bigint) -> bigint, VectorUDAFSumLong(col 14:bigint) -> bigint, VectorUDAFSumDouble(col 15:double) -> double, VectorUDAFMinDouble(col 16:double) -> double, VectorUDAFSumDouble(col 17:double) -> double, VectorUDAFSumDouble(col 18:double) -> double, VectorUDAFCountMerge(col 19:bigint) -> bigint - className: VectorGroupByOperator - groupByMode: MERGEPARTIAL - keyExpressions: col 0:timestamp, col 1:string - native: false - vectorProcessingMode: MERGE_PARTIAL - projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] + Top N Key Operator + sort order: ++ keys: KEY._col0 (type: timestamp), KEY._col1 (type: string) - mode: mergepartial - outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 + null sort order: zz Statistics: Num rows: 5980 Data size: 1435604 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: timestamp), _col1 (type: string), power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) (type: double), (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D) (type: double), (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), (UDFToDouble(_col5) / _col6) (type: double), (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), (-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), _col7 (type: bigint), (- _col7) (type: bigint), ((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) (type: double), _col8 (type: tinyint), (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7))) (type: double), (- (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D)) (type: double), ((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) (type: double), (((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) (type: double), (- (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) (type: double), (UDFToDouble((- _col7)) / power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), ((_col11 - ((_col12 * _col12) / _col13)) / _col13) (type: double), (10.175D / (UDFToDouble(_col5) / _col6)) (type: double), (UDFToDouble(_col14) / _col4) (type: double), ((_col11 - ((_col12 * _col12) / _col13)) / CASE WHEN ((_col13 = 1L)) THEN (null) ELSE ((_col13 - 1)) END) (type: double), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) - (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) (type: double), (- (- (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D))) (type: double), (_col15 / _col13) (type: double), (((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) - (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) * 10.175D) (type: double), (10.175D % (10.175D / (UDFToDouble(_col5) / _col6))) (type: double), (- _col8) (type: tinyint), _col16 (type: double), ((_col9 - ((_col10 * _col10) / _col6)) / _col6) (type: double), (- ((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)))) (type: double), ((- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) % (_col15 / _col13)) (type: double), (-26.28 / CAST( (- _col8) AS decimal(3,0))) (type: decimal(8,6)), power(((_col17 - ((_col18 * _col18) / _col19)) / _col19), 0.5) (type: double), _col14 (type: bigint), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) / ((_col11 - ((_col12 * _col12) / _col13)) / _col13)) (type: double), (- (- _col7)) (type: bigint), _col7 (type: bigint), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) % -26.28D) (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 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1, 24, 30, 36, 38, 44, 50, 7, 51, 64, 8, 80, 87, 94, 118, 125, 133, 137, 140, 142, 149, 190, 198, 199, 241, 245, 246, 16, 250, 264, 272, 275, 280, 14, 309, 311, 7, 336] - selectExpressions: FuncPowerDoubleToDouble(col 23:double)(children: DoubleColDivideLongColumn(col 22:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 21:double)(children: DoubleColDivideLongColumn(col 20:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 20:double) -> 21:double) -> 22:double) -> 23:double) -> 24:double, DoubleColMultiplyDoubleScalar(col 29:double, val 10.175)(children: FuncPowerDoubleToDouble(col 28:double)(children: DoubleColDivideLongColumn(col 27:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 26:double)(children: DoubleColDivideLongColumn(col 25:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 25:double) -> 26:double) -> 27:double) -> 28:double) -> 29:double) -> 30:double, DoubleColUnaryMinus(col 35:double)(children: FuncPowerDoubleToDouble(col 34:double)(children: DoubleColDivideLongColumn(col 33:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 32:double)(children: DoubleColDivideLongColumn(col 31:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 31:double) -> 32:double) -> 33:double) -> 34:double) -> 35:double) -> 36:double, DoubleColDivideLongColumn(col 37:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 37:double) -> 38:double, DoubleColUnaryMinus(col 43:double)(children: FuncPowerDoubleToDouble(col 42:double)(children: DoubleColDivideLongColumn(col 41:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 40:double)(children: DoubleColDivideLongColumn(col 39:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 39:double) -> 40:double) -> 41:double) -> 42:double) -> 43:double) -> 44:double, DoubleScalarSubtractDoubleColumn(val -26.28, col 49:double)(children: FuncPowerDoubleToDouble(col 48:double)(children: DoubleColDivideLongColumn(col 47:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 46:double)(children: DoubleColDivideLongColumn(col 45:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 45:double) -> 46:double) -> 47:double) -> 48:double) -> 49:double) -> 50:double, LongColUnaryMinus(col 7:bigint) -> 51:bigint, DoubleColMultiplyDoubleColumn(col 57:double, col 63:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 56:double)(children: FuncPowerDoubleToDouble(col 55:double)(children: DoubleColDivideLongColumn(col 54:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 53:double)(children: DoubleColDivideLongColumn(col 52:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 52:double) -> 53:double) -> 54:double) -> 55:double) -> 56:double) -> 57:double, DoubleColUnaryMinus(col 62:double)(children: FuncPowerDoubleToDouble(col 61:double)(children: DoubleColDivideLongColumn(col 60:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 59:double)(children: DoubleColDivideLongColumn(col 58:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 58:double) -> 59:double) -> 60:double) -> 61:double) -> 62:double) -> 63:double) -> 64:double, DoubleColMultiplyDoubleColumn(col 77:double, col 79:double)(children: DoubleColMultiplyDoubleColumn(col 70:double, col 76:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 69:double)(children: FuncPowerDoubleToDouble(col 68:double)(children: DoubleColDivideLongColumn(col 67:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 66:double)(children: DoubleColDivideLongColumn(col 65:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 65:double) -> 66:double) -> 67:double) -> 68:double) -> 69:double) -> 70:double, DoubleColUnaryMinus(col 75:double)(children: FuncPowerDoubleToDouble(col 74:double)(children: DoubleColDivideLongColumn(col 73:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 72:double)(children: DoubleColDivideLongColumn(col 71:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 71:double) -> 72:double) -> 73:double) -> 74:double) -> 75:double) -> 76:double) -> 77:double, CastLongToDouble(col 78:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 78:bigint) -> 79:double) -> 80:double, DoubleColUnaryMinus(col 86:double)(children: DoubleColMultiplyDoubleScalar(col 85:double, val 10.175)(children: FuncPowerDoubleToDouble(col 84:double)(children: DoubleColDivideLongColumn(col 83:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 82:double)(children: DoubleColDivideLongColumn(col 81:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 81:double) -> 82:double) -> 83:double) -> 84:double) -> 85:double) -> 86:double) -> 87:double, DoubleColDivideLongColumn(col 90:double, col 93:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 89:double)(children: DoubleColDivideLongColumn(col 88:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 88:double) -> 89:double) -> 90:double, IfExprNullCondExpr(col 91:boolean, null, col 92:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 91:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 92:bigint) -> 93:bigint) -> 94:double, DoubleColAddDoubleColumn(col 101:double, col 117:double)(children: DoubleColDivideLongColumn(col 97:double, col 100:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 96:double)(children: DoubleColDivideLongColumn(col 95:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 95:double) -> 96:double) -> 97:double, IfExprNullCondExpr(col 98:boolean, null, col 99:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 98:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 99:bigint) -> 100:bigint) -> 101:double, DoubleColMultiplyDoubleColumn(col 114:double, col 116:double)(children: DoubleColMultiplyDoubleColumn(col 107:double, col 113:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 106:double)(children: FuncPowerDoubleToDouble(col 105:double)(children: DoubleColDivideLongColumn(col 104:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 103:double)(children: DoubleColDivideLongColumn(col 102:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 102:double) -> 103:double) -> 104:double) -> 105:double) -> 106:double) -> 107:double, DoubleColUnaryMinus(col 112:double)(children: FuncPowerDoubleToDouble(col 111:double)(children: DoubleColDivideLongColumn(col 110:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 109:double)(children: DoubleColDivideLongColumn(col 108:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 108:double) -> 109:double) -> 110:double) -> 111:double) -> 112:double) -> 113:double) -> 114:double, CastLongToDouble(col 115:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 115:bigint) -> 116:double) -> 117:double) -> 118:double, DoubleColUnaryMinus(col 124:double)(children: DoubleColUnaryMinus(col 123:double)(children: FuncPowerDoubleToDouble(col 122:double)(children: DoubleColDivideLongColumn(col 121:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 120:double)(children: DoubleColDivideLongColumn(col 119:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 119:double) -> 120:double) -> 121:double) -> 122:double) -> 123:double) -> 124:double) -> 125:double, DoubleColDivideDoubleColumn(col 127:double, col 132:double)(children: CastLongToDouble(col 126:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 126:bigint) -> 127:double, FuncPowerDoubleToDouble(col 131:double)(children: DoubleColDivideLongColumn(col 130:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 129:double)(children: DoubleColDivideLongColumn(col 128:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 128:double) -> 129:double) -> 130:double) -> 131:double) -> 132:double) -> 133:double, DoubleColDivideLongColumn(col 136:double, col 13:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 135:double)(children: DoubleColDivideLongColumn(col 134:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 134:double) -> 135:double) -> 136:double) -> 137:double, DoubleScalarDivideDoubleColumn(val 10.175, col 139:double)(children: DoubleColDivideLongColumn(col 138:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 138:double) -> 139:double) -> 140:double, DoubleColDivideLongColumn(col 141:double, col 4:bigint)(children: CastLongToDouble(col 14:bigint) -> 141:double) -> 142:double, DoubleColDivideLongColumn(col 145:double, col 148:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 144:double)(children: DoubleColDivideLongColumn(col 143:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 143:double) -> 144:double) -> 145:double, IfExprNullCondExpr(col 146:boolean, null, col 147:bigint)(children: LongColEqualLongScalar(col 13:bigint, val 1) -> 146:boolean, LongColSubtractLongScalar(col 13:bigint, val 1) -> 147:bigint) -> 148:bigint) -> 149:double, DoubleColSubtractDoubleColumn(col 173:double, col 189:double)(children: DoubleColAddDoubleColumn(col 156:double, col 172:double)(children: DoubleColDivideLongColumn(col 152:double, col 155:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 151:double)(children: DoubleColDivideLongColumn(col 150:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 150:double) -> 151:double) -> 152:double, IfExprNullCondExpr(col 153:boolean, null, col 154:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 153:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 154:bigint) -> 155:bigint) -> 156:double, DoubleColMultiplyDoubleColumn(col 169:double, col 171:double)(children: DoubleColMultiplyDoubleColumn(col 162:double, col 168:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 161:double)(children: FuncPowerDoubleToDouble(col 160:double)(children: DoubleColDivideLongColumn(col 159:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 158:double)(children: DoubleColDivideLongColumn(col 157:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 157:double) -> 158:double) -> 159:double) -> 160:double) -> 161:double) -> 162:double, DoubleColUnaryMinus(col 167:double)(children: FuncPowerDoubleToDouble(col 166:double)(children: DoubleColDivideLongColumn(col 165:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 164:double)(children: DoubleColDivideLongColumn(col 163:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 163:double) -> 164:double) -> 165:double) -> 166:double) -> 167:double) -> 168:double) -> 169:double, CastLongToDouble(col 170:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 170:bigint) -> 171:double) -> 172:double) -> 173:double, DoubleColMultiplyDoubleColumn(col 186:double, col 188:double)(children: DoubleColMultiplyDoubleColumn(col 179:double, col 185:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 178:double)(children: FuncPowerDoubleToDouble(col 177:double)(children: DoubleColDivideLongColumn(col 176:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 175:double)(children: DoubleColDivideLongColumn(col 174:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 174:double) -> 175:double) -> 176:double) -> 177:double) -> 178:double) -> 179:double, DoubleColUnaryMinus(col 184:double)(children: FuncPowerDoubleToDouble(col 183:double)(children: DoubleColDivideLongColumn(col 182:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 181:double)(children: DoubleColDivideLongColumn(col 180:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 180:double) -> 181:double) -> 182:double) -> 183:double) -> 184:double) -> 185:double) -> 186:double, CastLongToDouble(col 187:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 187:bigint) -> 188:double) -> 189:double) -> 190:double, DoubleColUnaryMinus(col 197:double)(children: DoubleColUnaryMinus(col 196:double)(children: DoubleColMultiplyDoubleScalar(col 195:double, val 10.175)(children: FuncPowerDoubleToDouble(col 194:double)(children: DoubleColDivideLongColumn(col 193:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 192:double)(children: DoubleColDivideLongColumn(col 191:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 191:double) -> 192:double) -> 193:double) -> 194:double) -> 195:double) -> 196:double) -> 197:double) -> 198:double, DoubleColDivideLongColumn(col 15:double, col 13:bigint) -> 199:double, DoubleColMultiplyDoubleScalar(col 240:double, val 10.175)(children: DoubleColSubtractDoubleColumn(col 223:double, col 239:double)(children: DoubleColAddDoubleColumn(col 206:double, col 222:double)(children: DoubleColDivideLongColumn(col 202:double, col 205:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 201:double)(children: DoubleColDivideLongColumn(col 200:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 200:double) -> 201:double) -> 202:double, IfExprNullCondExpr(col 203:boolean, null, col 204:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 203:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 204:bigint) -> 205:bigint) -> 206:double, DoubleColMultiplyDoubleColumn(col 219:double, col 221:double)(children: DoubleColMultiplyDoubleColumn(col 212:double, col 218:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 211:double)(children: FuncPowerDoubleToDouble(col 210:double)(children: DoubleColDivideLongColumn(col 209:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 208:double)(children: DoubleColDivideLongColumn(col 207:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 207:double) -> 208:double) -> 209:double) -> 210:double) -> 211:double) -> 212:double, DoubleColUnaryMinus(col 217:double)(children: FuncPowerDoubleToDouble(col 216:double)(children: DoubleColDivideLongColumn(col 215:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 214:double)(children: DoubleColDivideLongColumn(col 213:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 213:double) -> 214:double) -> 215:double) -> 216:double) -> 217:double) -> 218:double) -> 219:double, CastLongToDouble(col 220:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 220:bigint) -> 221:double) -> 222:double) -> 223:double, DoubleColMultiplyDoubleColumn(col 236:double, col 238:double)(children: DoubleColMultiplyDoubleColumn(col 229:double, col 235:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 228:double)(children: FuncPowerDoubleToDouble(col 227:double)(children: DoubleColDivideLongColumn(col 226:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 225:double)(children: DoubleColDivideLongColumn(col 224:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 224:double) -> 225:double) -> 226:double) -> 227:double) -> 228:double) -> 229:double, DoubleColUnaryMinus(col 234:double)(children: FuncPowerDoubleToDouble(col 233:double)(children: DoubleColDivideLongColumn(col 232:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 231:double)(children: DoubleColDivideLongColumn(col 230:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 230:double) -> 231:double) -> 232:double) -> 233:double) -> 234:double) -> 235:double) -> 236:double, CastLongToDouble(col 237:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 237:bigint) -> 238:double) -> 239:double) -> 240:double) -> 241:double, DoubleScalarModuloDoubleColumn(val 10.175, col 244:double)(children: DoubleScalarDivideDoubleColumn(val 10.175, col 243:double)(children: DoubleColDivideLongColumn(col 242:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 242:double) -> 243:double) -> 244:double) -> 245:double, LongColUnaryMinus(col 8:tinyint) -> 246:tinyint, DoubleColDivideLongColumn(col 249:double, col 6:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 248:double)(children: DoubleColDivideLongColumn(col 247:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 247:double) -> 248:double) -> 249:double) -> 250:double, DoubleColUnaryMinus(col 263:double)(children: DoubleColMultiplyDoubleColumn(col 256:double, col 262:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 255:double)(children: FuncPowerDoubleToDouble(col 254:double)(children: DoubleColDivideLongColumn(col 253:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 252:double)(children: DoubleColDivideLongColumn(col 251:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 251:double) -> 252:double) -> 253:double) -> 254:double) -> 255:double) -> 256:double, DoubleColUnaryMinus(col 261:double)(children: FuncPowerDoubleToDouble(col 260:double)(children: DoubleColDivideLongColumn(col 259:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 258:double)(children: DoubleColDivideLongColumn(col 257:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 257:double) -> 258:double) -> 259:double) -> 260:double) -> 261:double) -> 262:double) -> 263:double) -> 264:double, DoubleColModuloDoubleColumn(col 270:double, col 271:double)(children: DoubleColUnaryMinus(col 269:double)(children: FuncPowerDoubleToDouble(col 268:double)(children: DoubleColDivideLongColumn(col 267:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 266:double)(children: DoubleColDivideLongColumn(col 265:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 265:double) -> 266:double) -> 267:double) -> 268:double) -> 269:double) -> 270:double, DoubleColDivideLongColumn(col 15:double, col 13:bigint) -> 271:double) -> 272:double, DecimalScalarDivideDecimalColumn(val -26.28, col 274:decimal(3,0))(children: CastLongToDecimal(col 273:tinyint)(children: LongColUnaryMinus(col 8:tinyint) -> 273:tinyint) -> 274:decimal(3,0)) -> 275:decimal(8,6), FuncPowerDoubleToDouble(col 279:double)(children: DoubleColDivideLongColumn(col 278:double, col 19:bigint)(children: DoubleColSubtractDoubleColumn(col 17:double, col 277:double)(children: DoubleColDivideLongColumn(col 276:double, col 19:bigint)(children: DoubleColMultiplyDoubleColumn(col 18:double, col 18:double) -> 276:double) -> 277:double) -> 278:double) -> 279:double) -> 280:double, DoubleColDivideDoubleColumn(col 304:double, col 308:double)(children: DoubleColAddDoubleColumn(col 287:double, col 303:double)(children: DoubleColDivideLongColumn(col 283:double, col 286:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 282:double)(children: DoubleColDivideLongColumn(col 281:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 281:double) -> 282:double) -> 283:double, IfExprNullCondExpr(col 284:boolean, null, col 285:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 284:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 285:bigint) -> 286:bigint) -> 287:double, DoubleColMultiplyDoubleColumn(col 300:double, col 302:double)(children: DoubleColMultiplyDoubleColumn(col 293:double, col 299:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 292:double)(children: FuncPowerDoubleToDouble(col 291:double)(children: DoubleColDivideLongColumn(col 290:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 289:double)(children: DoubleColDivideLongColumn(col 288:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 288:double) -> 289:double) -> 290:double) -> 291:double) -> 292:double) -> 293:double, DoubleColUnaryMinus(col 298:double)(children: FuncPowerDoubleToDouble(col 297:double)(children: DoubleColDivideLongColumn(col 296:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 295:double)(children: DoubleColDivideLongColumn(col 294:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 294:double) -> 295:double) -> 296:double) -> 297:double) -> 298:double) -> 299:double) -> 300:double, CastLongToDouble(col 301:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 301:bigint) -> 302:double) -> 303:double) -> 304:double, DoubleColDivideLongColumn(col 307:double, col 13:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 306:double)(children: DoubleColDivideLongColumn(col 305:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 305:double) -> 306:double) -> 307:double) -> 308:double) -> 309:double, LongColUnaryMinus(col 310:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 310:bigint) -> 311:bigint, DoubleColModuloDoubleScalar(col 335:double, val -26.28)(children: DoubleColAddDoubleColumn(col 318:double, col 334:double)(children: DoubleColDivideLongColumn(col 314:double, col 317:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 313:double)(children: DoubleColDivideLongColumn(col 312:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 312:double) -> 313:double) -> 314:double, IfExprNullCondExpr(col 315:boolean, null, col 316:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 315:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 316:bigint) -> 317:bigint) -> 318:double, DoubleColMultiplyDoubleColumn(col 331:double, col 333:double)(children: DoubleColMultiplyDoubleColumn(col 324:double, col 330:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 323:double)(children: FuncPowerDoubleToDouble(col 322:double)(children: DoubleColDivideLongColumn(col 321:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 320:double)(children: DoubleColDivideLongColumn(col 319:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 319:double) -> 320:double) -> 321:double) -> 322:double) -> 323:double) -> 324:double, DoubleColUnaryMinus(col 329:double)(children: FuncPowerDoubleToDouble(col 328:double)(children: DoubleColDivideLongColumn(col 327:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 326:double)(children: DoubleColDivideLongColumn(col 325:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 325:double) -> 326:double) -> 327:double) -> 328:double) -> 329:double) -> 330:double) -> 331:double, CastLongToDouble(col 332:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 332:bigint) -> 333:double) -> 334:double) -> 335:double) -> 336:double - Statistics: Num rows: 5980 Data size: 2942564 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: timestamp), _col1 (type: string), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: bigint), _col9 (type: bigint), _col10 (type: double), _col11 (type: tinyint), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: double), _col16 (type: double), _col17 (type: double), _col18 (type: double), _col19 (type: double), _col20 (type: double), _col21 (type: double), _col22 (type: double), _col23 (type: double), _col24 (type: double), _col25 (type: double), _col26 (type: double), _col27 (type: tinyint), _col28 (type: double), _col29 (type: double), _col30 (type: double), _col31 (type: double), _col32 (type: decimal(8,6)), _col33 (type: double), _col34 (type: bigint), _col35 (type: double), _col36 (type: bigint), _col37 (type: bigint), _col38 (type: double) - null sort order: zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz + top n: 50 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:timestamp, col 1:string + native: true + Group By Operator + aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), count(VALUE._col5), min(VALUE._col6), sum(VALUE._col7), sum(VALUE._col8), sum(VALUE._col9), sum(VALUE._col10), count(VALUE._col11), sum(VALUE._col12), sum(VALUE._col13), min(VALUE._col14), sum(VALUE._col15), sum(VALUE._col16), count(VALUE._col17) + Group By Vectorization: + aggregators: VectorUDAFSumDouble(col 2:double) -> double, VectorUDAFSumDouble(col 3:double) -> double, VectorUDAFCountMerge(col 4:bigint) -> bigint, VectorUDAFSumLong(col 5:bigint) -> bigint, VectorUDAFCountMerge(col 6:bigint) -> bigint, VectorUDAFCountMerge(col 7:bigint) -> bigint, VectorUDAFMinLong(col 8:tinyint) -> tinyint, VectorUDAFSumDouble(col 9:double) -> double, VectorUDAFSumDouble(col 10:double) -> double, VectorUDAFSumDouble(col 11:double) -> double, VectorUDAFSumDouble(col 12:double) -> double, VectorUDAFCountMerge(col 13:bigint) -> bigint, VectorUDAFSumLong(col 14:bigint) -> bigint, VectorUDAFSumDouble(col 15:double) -> double, VectorUDAFMinDouble(col 16:double) -> double, VectorUDAFSumDouble(col 17:double) -> double, VectorUDAFSumDouble(col 18:double) -> double, VectorUDAFCountMerge(col 19:bigint) -> bigint + className: VectorGroupByOperator + groupByMode: MERGEPARTIAL + keyExpressions: col 0:timestamp, col 1:string + native: false + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17] + keys: KEY._col0 (type: timestamp), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19 + Statistics: Num rows: 5980 Data size: 1232554 Basic stats: COMPLETE Column stats: COMPLETE + Top N Key Operator sort order: +++++++++++++++++++++++++++++++++++++++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + keys: _col0 (type: timestamp), _col1 (type: string), power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) (type: double), (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D) (type: double), (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), (UDFToDouble(_col5) / _col6) (type: double), (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), (-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), _col7 (type: bigint), (- _col7) (type: bigint), ((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) (type: double), _col8 (type: tinyint), (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7))) (type: double), (- (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D)) (type: double), ((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) (type: double), (((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) (type: double), (- (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) (type: double), (UDFToDouble((- _col7)) / power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), ((_col11 - ((_col12 * _col12) / _col13)) / _col13) (type: double), (10.175D / (UDFToDouble(_col5) / _col6)) (type: double), (UDFToDouble(_col14) / _col4) (type: double), ((_col11 - ((_col12 * _col12) / _col13)) / CASE WHEN ((_col13 = 1L)) THEN (null) ELSE ((_col13 - 1)) END) (type: double), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) - (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) (type: double), (- (- (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D))) (type: double), (_col15 / _col13) (type: double), (((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) - (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) * 10.175D) (type: double), (10.175D % (10.175D / (UDFToDouble(_col5) / _col6))) (type: double), (- _col8) (type: tinyint), _col16 (type: double), ((_col9 - ((_col10 * _col10) / _col6)) / _col6) (type: double), (- ((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)))) (type: double), ((- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) % (_col15 / _col13)) (type: double), (-26.28 / CAST( (- _col8) AS decimal(3,0))) (type: decimal(8,6)), power(((_col17 - ((_col18 * _col18) / _col19)) / _col19), 0.5) (type: double), _col14 (type: bigint), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) / ((_col11 - ((_col12 * _col12) / _col13)) / _col13)) (type: double), (- (- _col7)) (type: bigint), _col7 (type: bigint), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) % -26.28D) (type: double) + null sort order: zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz + Statistics: Num rows: 5980 Data size: 1232554 Basic stats: COMPLETE Column stats: COMPLETE + top n: 50 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:timestamp, col 1:string, FuncPowerDoubleToDouble(col 23:double)(children: DoubleColDivideLongColumn(col 22:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 21:double)(children: DoubleColDivideLongColumn(col 20:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 20:double) -> 21:double) -> 22:double) -> 23:double) -> 24:double, DoubleColMultiplyDoubleScalar(col 29:double, val 10.175)(children: FuncPowerDoubleToDouble(col 28:double)(children: DoubleColDivideLongColumn(col 27:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 26:double)(children: DoubleColDivideLongColumn(col 25:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 25:double) -> 26:double) -> 27:double) -> 28:double) -> 29:double) -> 30:double, DoubleColUnaryMinus(col 35:double)(children: FuncPowerDoubleToDouble(col 34:double)(children: DoubleColDivideLongColumn(col 33:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 32:double)(children: DoubleColDivideLongColumn(col 31:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 31:double) -> 32:double) -> 33:double) -> 34:double) -> 35:double) -> 36:double, DoubleColDivideLongColumn(col 37:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 37:double) -> 38:double, DoubleColUnaryMinus(col 43:double)(children: FuncPowerDoubleToDouble(col 42:double)(children: DoubleColDivideLongColumn(col 41:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 40:double)(children: DoubleColDivideLongColumn(col 39:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 39:double) -> 40:double) -> 41:double) -> 42:double) -> 43:double) -> 44:double, DoubleScalarSubtractDoubleColumn(val -26.28, col 49:double)(children: FuncPowerDoubleToDouble(col 48:double)(children: DoubleColDivideLongColumn(col 47:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 46:double)(children: DoubleColDivideLongColumn(col 45:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 45:double) -> 46:double) -> 47:double) -> 48:double) -> 49:double) -> 50:double, col 7:bigint, LongColUnaryMinus(col 7:bigint) -> 51:bigint, DoubleColMultiplyDoubleColumn(col 57:double, col 63:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 56:double)(children: FuncPowerDoubleToDouble(col 55:double)(children: DoubleColDivideLongColumn(col 54:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 53:double)(children: DoubleColDivideLongColumn(col 52:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 52:double) -> 53:double) -> 54:double) -> 55:double) -> 56:double) -> 57:double, DoubleColUnaryMinus(col 62:double)(children: FuncPowerDoubleToDouble(col 61:double)(children: DoubleColDivideLongColumn(col 60:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 59:double)(children: DoubleColDivideLongColumn(col 58:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 58:double) -> 59:double) -> 60:double) -> 61:double) -> 62:double) -> 63:double) -> 64:double, col 8:tinyint, DoubleColMultiplyDoubleColumn(col 77:double, col 79:double)(children: DoubleColMultiplyDoubleColumn(col 70:double, col 76:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 69:double)(children: FuncPowerDoubleToDouble(col 68:double)(children: DoubleColDivideLongColumn(col 67:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 66:double)(children: DoubleColDivideLongColumn(col 65:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 65:double) -> 66:double) -> 67:double) -> 68:double) -> 69:double) -> 70:double, DoubleColUnaryMinus(col 75:double)(children: FuncPowerDoubleToDouble(col 74:double)(children: DoubleColDivideLongColumn(col 73:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 72:double)(children: DoubleColDivideLongColumn(col 71:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 71:double) -> 72:double) -> 73:double) -> 74:double) -> 75:double) -> 76:double) -> 77:double, CastLongToDouble(col 78:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 78:bigint) -> 79:double) -> 80:double, DoubleColUnaryMinus(col 86:double)(children: DoubleColMultiplyDoubleScalar(col 85:double, val 10.175)(children: FuncPowerDoubleToDouble(col 84:double)(children: DoubleColDivideLongColumn(col 83:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 82:double)(children: DoubleColDivideLongColumn(col 81:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 81:double) -> 82:double) -> 83:double) -> 84:double) -> 85:double) -> 86:double) -> 87:double, DoubleColDivideLongColumn(col 90:double, col 93:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 89:double)(children: DoubleColDivideLongColumn(col 88:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 88:double) -> 89:double) -> 90:double, IfExprNullCondExpr(col 91:boolean, null, col 92:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 91:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 92:bigint) -> 93:bigint) -> 94:double, DoubleColAddDoubleColumn(col 101:double, col 117:double)(children: DoubleColDivideLongColumn(col 97:double, col 100:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 96:double)(children: DoubleColDivideLongColumn(col 95:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 95:double) -> 96:double) -> 97:double, IfExprNullCondExpr(col 98:boolean, null, col 99:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 98:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 99:bigint) -> 100:bigint) -> 101:double, DoubleColMultiplyDoubleColumn(col 114:double, col 116:double)(children: DoubleColMultiplyDoubleColumn(col 107:double, col 113:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 106:double)(children: FuncPowerDoubleToDouble(col 105:double)(children: DoubleColDivideLongColumn(col 104:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 103:double)(children: DoubleColDivideLongColumn(col 102:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 102:double) -> 103:double) -> 104:double) -> 105:double) -> 106:double) -> 107:double, DoubleColUnaryMinus(col 112:double)(children: FuncPowerDoubleToDouble(col 111:double)(children: DoubleColDivideLongColumn(col 110:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 109:double)(children: DoubleColDivideLongColumn(col 108:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 108:double) -> 109:double) -> 110:double) -> 111:double) -> 112:double) -> 113:double) -> 114:double, CastLongToDouble(col 115:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 115:bigint) -> 116:double) -> 117:double) -> 118:double, DoubleColUnaryMinus(col 124:double)(children: DoubleColUnaryMinus(col 123:double)(children: FuncPowerDoubleToDouble(col 122:double)(children: DoubleColDivideLongColumn(col 121:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 120:double)(children: DoubleColDivideLongColumn(col 119:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 119:double) -> 120:double) -> 121:double) -> 122:double) -> 123:double) -> 124:double) -> 125:double, DoubleColDivideDoubleColumn(col 127:double, col 132:double)(children: CastLongToDouble(col 126:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 126:bigint) -> 127:double, FuncPowerDoubleToDouble(col 131:double)(children: DoubleColDivideLongColumn(col 130:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 129:double)(children: DoubleColDivideLongColumn(col 128:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 128:double) -> 129:double) -> 130:double) -> 131:double) -> 132:double) -> 133:double, DoubleColDivideLongColumn(col 136:double, col 13:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 135:double)(children: DoubleColDivideLongColumn(col 134:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 134:double) -> 135:double) -> 136:double) -> 137:double, DoubleScalarDivideDoubleColumn(val 10.175, col 139:double)(children: DoubleColDivideLongColumn(col 138:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 138:double) -> 139:double) -> 140:double, DoubleColDivideLongColumn(col 141:double, col 4:bigint)(children: CastLongToDouble(col 14:bigint) -> 141:double) -> 142:double, DoubleColDivideLongColumn(col 145:double, col 148:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 144:double)(children: DoubleColDivideLongColumn(col 143:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 143:double) -> 144:double) -> 145:double, IfExprNullCondExpr(col 146:boolean, null, col 147:bigint)(children: LongColEqualLongScalar(col 13:bigint, val 1) -> 146:boolean, LongColSubtractLongScalar(col 13:bigint, val 1) -> 147:bigint) -> 148:bigint) -> 149:double, DoubleColSubtractDoubleColumn(col 173:double, col 189:double)(children: DoubleColAddDoubleColumn(col 156:double, col 172:double)(children: DoubleColDivideLongColumn(col 152:double, col 155:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 151:double)(children: DoubleColDivideLongColumn(col 150:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 150:double) -> 151:double) -> 152:double, IfExprNullCondExpr(col 153:boolean, null, col 154:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 153:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 154:bigint) -> 155:bigint) -> 156:double, DoubleColMultiplyDoubleColumn(col 169:double, col 171:double)(children: DoubleColMultiplyDoubleColumn(col 162:double, col 168:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 161:double)(children: FuncPowerDoubleToDouble(col 160:double)(children: DoubleColDivideLongColumn(col 159:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 158:double)(children: DoubleColDivideLongColumn(col 157:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 157:double) -> 158:double) -> 159:double) -> 160:double) -> 161:double) -> 162:double, DoubleColUnaryMinus(col 167:double)(children: FuncPowerDoubleToDouble(col 166:double)(children: DoubleColDivideLongColumn(col 165:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 164:double)(children: DoubleColDivideLongColumn(col 163:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 163:double) -> 164:double) -> 165:double) -> 166:double) -> 167:double) -> 168:double) -> 169:double, CastLongToDouble(col 170:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 170:bigint) -> 171:double) -> 172:double) -> 173:double, DoubleColMultiplyDoubleColumn(col 186:double, col 188:double)(children: DoubleColMultiplyDoubleColumn(col 179:double, col 185:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 178:double)(children: FuncPowerDoubleToDouble(col 177:double)(children: DoubleColDivideLongColumn(col 176:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 175:double)(children: DoubleColDivideLongColumn(col 174:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 174:double) -> 175:double) -> 176:double) -> 177:double) -> 178:double) -> 179:double, DoubleColUnaryMinus(col 184:double)(children: FuncPowerDoubleToDouble(col 183:double)(children: DoubleColDivideLongColumn(col 182:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 181:double)(children: DoubleColDivideLongColumn(col 180:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 180:double) -> 181:double) -> 182:double) -> 183:double) -> 184:double) -> 185:double) -> 186:double, CastLongToDouble(col 187:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 187:bigint) -> 188:double) -> 189:double) -> 190:double, DoubleColUnaryMinus(col 197:double)(children: DoubleColUnaryMinus(col 196:double)(children: DoubleColMultiplyDoubleScalar(col 195:double, val 10.175)(children: FuncPowerDoubleToDouble(col 194:double)(children: DoubleColDivideLongColumn(col 193:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 192:double)(children: DoubleColDivideLongColumn(col 191:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 191:double) -> 192:double) -> 193:double) -> 194:double) -> 195:double) -> 196:double) -> 197:double) -> 198:double, DoubleColDivideLongColumn(col 15:double, col 13:bigint) -> 199:double, DoubleColMultiplyDoubleScalar(col 240:double, val 10.175)(children: DoubleColSubtractDoubleColumn(col 223:double, col 239:double)(children: DoubleColAddDoubleColumn(col 206:double, col 222:double)(children: DoubleColDivideLongColumn(col 202:double, col 205:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 201:double)(children: DoubleColDivideLongColumn(col 200:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 200:double) -> 201:double) -> 202:double, IfExprNullCondExpr(col 203:boolean, null, col 204:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 203:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 204:bigint) -> 205:bigint) -> 206:double, DoubleColMultiplyDoubleColumn(col 219:double, col 221:double)(children: DoubleColMultiplyDoubleColumn(col 212:double, col 218:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 211:double)(children: FuncPowerDoubleToDouble(col 210:double)(children: DoubleColDivideLongColumn(col 209:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 208:double)(children: DoubleColDivideLongColumn(col 207:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 207:double) -> 208:double) -> 209:double) -> 210:double) -> 211:double) -> 212:double, DoubleColUnaryMinus(col 217:double)(children: FuncPowerDoubleToDouble(col 216:double)(children: DoubleColDivideLongColumn(col 215:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 214:double)(children: DoubleColDivideLongColumn(col 213:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 213:double) -> 214:double) -> 215:double) -> 216:double) -> 217:double) -> 218:double) -> 219:double, CastLongToDouble(col 220:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 220:bigint) -> 221:double) -> 222:double) -> 223:double, DoubleColMultiplyDoubleColumn(col 236:double, col 238:double)(children: DoubleColMultiplyDoubleColumn(col 229:double, col 235:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 228:double)(children: FuncPowerDoubleToDouble(col 227:double)(children: DoubleColDivideLongColumn(col 226:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 225:double)(children: DoubleColDivideLongColumn(col 224:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 224:double) -> 225:double) -> 226:double) -> 227:double) -> 228:double) -> 229:double, DoubleColUnaryMinus(col 234:double)(children: FuncPowerDoubleToDouble(col 233:double)(children: DoubleColDivideLongColumn(col 232:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 231:double)(children: DoubleColDivideLongColumn(col 230:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 230:double) -> 231:double) -> 232:double) -> 233:double) -> 234:double) -> 235:double) -> 236:double, CastLongToDouble(col 237:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 237:bigint) -> 238:double) -> 239:double) -> 240:double) -> 241:double, DoubleScalarModuloDoubleColumn(val 10.175, col 244:double)(children: DoubleScalarDivideDoubleColumn(val 10.175, col 243:double)(children: DoubleColDivideLongColumn(col 242:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 242:double) -> 243:double) -> 244:double) -> 245:double, LongColUnaryMinus(col 8:tinyint) -> 246:tinyint, col 16:double, DoubleColDivideLongColumn(col 249:double, col 6:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 248:double)(children: DoubleColDivideLongColumn(col 247:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 247:double) -> 248:double) -> 249:double) -> 250:double, DoubleColUnaryMinus(col 263:double)(children: DoubleColMultiplyDoubleColumn(col 256:double, col 262:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 255:double)(children: FuncPowerDoubleToDouble(col 254:double)(children: DoubleColDivideLongColumn(col 253:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 252:double)(children: DoubleColDivideLongColumn(col 251:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 251:double) -> 252:double) -> 253:double) -> 254:double) -> 255:double) -> 256:double, DoubleColUnaryMinus(col 261:double)(children: FuncPowerDoubleToDouble(col 260:double)(children: DoubleColDivideLongColumn(col 259:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 258:double)(children: DoubleColDivideLongColumn(col 257:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 257:double) -> 258:double) -> 259:double) -> 260:double) -> 261:double) -> 262:double) -> 263:double) -> 264:double, DoubleColModuloDoubleColumn(col 270:double, col 271:double)(children: DoubleColUnaryMinus(col 269:double)(children: FuncPowerDoubleToDouble(col 268:double)(children: DoubleColDivideLongColumn(col 267:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 266:double)(children: DoubleColDivideLongColumn(col 265:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 265:double) -> 266:double) -> 267:double) -> 268:double) -> 269:double) -> 270:double, DoubleColDivideLongColumn(col 15:double, col 13:bigint) -> 271:double) -> 272:double, DecimalScalarDivideDecimalColumn(val -26.28, col 274:decimal(3,0))(children: CastLongToDecimal(col 273:tinyint)(children: LongColUnaryMinus(col 8:tinyint) -> 273:tinyint) -> 274:decimal(3,0)) -> 275:decimal(8,6), FuncPowerDoubleToDouble(col 279:double)(children: DoubleColDivideLongColumn(col 278:double, col 19:bigint)(children: DoubleColSubtractDoubleColumn(col 17:double, col 277:double)(children: DoubleColDivideLongColumn(col 276:double, col 19:bigint)(children: DoubleColMultiplyDoubleColumn(col 18:double, col 18:double) -> 276:double) -> 277:double) -> 278:double) -> 279:double) -> 280:double, col 14:bigint, DoubleColDivideDoubleColumn(col 304:double, col 308:double)(children: DoubleColAddDoubleColumn(col 287:double, col 303:double)(children: DoubleColDivideLongColumn(col 283:double, col 286:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 282:double)(children: DoubleColDivideLongColumn(col 281:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 281:double) -> 282:double) -> 283:double, IfExprNullCondExpr(col 284:boolean, null, col 285:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 284:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 285:bigint) -> 286:bigint) -> 287:double, DoubleColMultiplyDoubleColumn(col 300:double, col 302:double)(children: DoubleColMultiplyDoubleColumn(col 293:double, col 299:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 292:double)(children: FuncPowerDoubleToDouble(col 291:double)(children: DoubleColDivideLongColumn(col 290:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 289:double)(children: DoubleColDivideLongColumn(col 288:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 288:double) -> 289:double) -> 290:double) -> 291:double) -> 292:double) -> 293:double, DoubleColUnaryMinus(col 298:double)(children: FuncPowerDoubleToDouble(col 297:double)(children: DoubleColDivideLongColumn(col 296:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 295:double)(children: DoubleColDivideLongColumn(col 294:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 294:double) -> 295:double) -> 296:double) -> 297:double) -> 298:double) -> 299:double) -> 300:double, CastLongToDouble(col 301:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 301:bigint) -> 302:double) -> 303:double) -> 304:double, DoubleColDivideLongColumn(col 307:double, col 13:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 306:double)(children: DoubleColDivideLongColumn(col 305:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 305:double) -> 306:double) -> 307:double) -> 308:double) -> 309:double, LongColUnaryMinus(col 310:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 310:bigint) -> 311:bigint, col 7:bigint, DoubleColModuloDoubleScalar(col 335:double, val -26.28)(children: DoubleColAddDoubleColumn(col 318:double, col 334:double)(children: DoubleColDivideLongColumn(col 314:double, col 317:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 313:double)(children: DoubleColDivideLongColumn(col 312:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 312:double) -> 313:double) -> 314:double, IfExprNullCondExpr(col 315:boolean, null, col 316:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 315:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 316:bigint) -> 317:bigint) -> 318:double, DoubleColMultiplyDoubleColumn(col 331:double, col 333:double)(children: DoubleColMultiplyDoubleColumn(col 324:double, col 330:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 323:double)(children: FuncPowerDoubleToDouble(col 322:double)(children: DoubleColDivideLongColumn(col 321:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 320:double)(children: DoubleColDivideLongColumn(col 319:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 319:double) -> 320:double) -> 321:double) -> 322:double) -> 323:double) -> 324:double, DoubleColUnaryMinus(col 329:double)(children: FuncPowerDoubleToDouble(col 328:double)(children: DoubleColDivideLongColumn(col 327:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 326:double)(children: DoubleColDivideLongColumn(col 325:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 325:double) -> 326:double) -> 327:double) -> 328:double) -> 329:double) -> 330:double) -> 331:double, CastLongToDouble(col 332:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 332:bigint) -> 333:double) -> 334:double) -> 335:double) -> 336:double native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 5980 Data size: 2942564 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Select Operator + expressions: _col0 (type: timestamp), _col1 (type: string), power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) (type: double), (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D) (type: double), (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), (UDFToDouble(_col5) / _col6) (type: double), (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), (-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), _col7 (type: bigint), (- _col7) (type: bigint), ((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) (type: double), _col8 (type: tinyint), (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7))) (type: double), (- (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D)) (type: double), ((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) (type: double), (((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) (type: double), (- (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) (type: double), (UDFToDouble((- _col7)) / power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: double), ((_col11 - ((_col12 * _col12) / _col13)) / _col13) (type: double), (10.175D / (UDFToDouble(_col5) / _col6)) (type: double), (UDFToDouble(_col14) / _col4) (type: double), ((_col11 - ((_col12 * _col12) / _col13)) / CASE WHEN ((_col13 = 1L)) THEN (null) ELSE ((_col13 - 1)) END) (type: double), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) - (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) (type: double), (- (- (power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5) * 10.175D))) (type: double), (_col15 / _col13) (type: double), (((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) - (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) * 10.175D) (type: double), (10.175D % (10.175D / (UDFToDouble(_col5) / _col6))) (type: double), (- _col8) (type: tinyint), _col16 (type: double), ((_col9 - ((_col10 * _col10) / _col6)) / _col6) (type: double), (- ((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)))) (type: double), ((- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) % (_col15 / _col13)) (type: double), (-26.28 / CAST( (- _col8) AS decimal(3,0))) (type: decimal(8,6)), power(((_col17 - ((_col18 * _col18) / _col19)) / _col19), 0.5) (type: double), _col14 (type: bigint), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) / ((_col11 - ((_col12 * _col12) / _col13)) / _col13)) (type: double), (- (- _col7)) (type: bigint), _col7 (type: bigint), ((((_col9 - ((_col10 * _col10) / _col6)) / CASE WHEN ((_col6 = 1L)) THEN (null) ELSE ((_col6 - 1)) END) + (((-26.28D - power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) * (- power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5))) * UDFToDouble((- _col7)))) % -26.28D) (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 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumnNums: [0, 1, 341, 347, 353, 355, 361, 367, 7, 368, 381, 8, 397, 404, 411, 435, 442, 450, 454, 457, 459, 466, 507, 515, 516, 558, 562, 563, 16, 567, 581, 589, 592, 597, 14, 626, 628, 7, 653] + selectExpressions: FuncPowerDoubleToDouble(col 340:double)(children: DoubleColDivideLongColumn(col 339:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 338:double)(children: DoubleColDivideLongColumn(col 337:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 337:double) -> 338:double) -> 339:double) -> 340:double) -> 341:double, DoubleColMultiplyDoubleScalar(col 346:double, val 10.175)(children: FuncPowerDoubleToDouble(col 345:double)(children: DoubleColDivideLongColumn(col 344:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 343:double)(children: DoubleColDivideLongColumn(col 342:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 342:double) -> 343:double) -> 344:double) -> 345:double) -> 346:double) -> 347:double, DoubleColUnaryMinus(col 352:double)(children: FuncPowerDoubleToDouble(col 351:double)(children: DoubleColDivideLongColumn(col 350:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 349:double)(children: DoubleColDivideLongColumn(col 348:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 348:double) -> 349:double) -> 350:double) -> 351:double) -> 352:double) -> 353:double, DoubleColDivideLongColumn(col 354:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 354:double) -> 355:double, DoubleColUnaryMinus(col 360:double)(children: FuncPowerDoubleToDouble(col 359:double)(children: DoubleColDivideLongColumn(col 358:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 357:double)(children: DoubleColDivideLongColumn(col 356:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 356:double) -> 357:double) -> 358:double) -> 359:double) -> 360:double) -> 361:double, DoubleScalarSubtractDoubleColumn(val -26.28, col 366:double)(children: FuncPowerDoubleToDouble(col 365:double)(children: DoubleColDivideLongColumn(col 364:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 363:double)(children: DoubleColDivideLongColumn(col 362:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 362:double) -> 363:double) -> 364:double) -> 365:double) -> 366:double) -> 367:double, LongColUnaryMinus(col 7:bigint) -> 368:bigint, DoubleColMultiplyDoubleColumn(col 374:double, col 380:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 373:double)(children: FuncPowerDoubleToDouble(col 372:double)(children: DoubleColDivideLongColumn(col 371:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 370:double)(children: DoubleColDivideLongColumn(col 369:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 369:double) -> 370:double) -> 371:double) -> 372:double) -> 373:double) -> 374:double, DoubleColUnaryMinus(col 379:double)(children: FuncPowerDoubleToDouble(col 378:double)(children: DoubleColDivideLongColumn(col 377:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 376:double)(children: DoubleColDivideLongColumn(col 375:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 375:double) -> 376:double) -> 377:double) -> 378:double) -> 379:double) -> 380:double) -> 381:double, DoubleColMultiplyDoubleColumn(col 394:double, col 396:double)(children: DoubleColMultiplyDoubleColumn(col 387:double, col 393:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 386:double)(children: FuncPowerDoubleToDouble(col 385:double)(children: DoubleColDivideLongColumn(col 384:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 383:double)(children: DoubleColDivideLongColumn(col 382:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 382:double) -> 383:double) -> 384:double) -> 385:double) -> 386:double) -> 387:double, DoubleColUnaryMinus(col 392:double)(children: FuncPowerDoubleToDouble(col 391:double)(children: DoubleColDivideLongColumn(col 390:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 389:double)(children: DoubleColDivideLongColumn(col 388:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 388:double) -> 389:double) -> 390:double) -> 391:double) -> 392:double) -> 393:double) -> 394:double, CastLongToDouble(col 395:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 395:bigint) -> 396:double) -> 397:double, DoubleColUnaryMinus(col 403:double)(children: DoubleColMultiplyDoubleScalar(col 402:double, val 10.175)(children: FuncPowerDoubleToDouble(col 401:double)(children: DoubleColDivideLongColumn(col 400:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 399:double)(children: DoubleColDivideLongColumn(col 398:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 398:double) -> 399:double) -> 400:double) -> 401:double) -> 402:double) -> 403:double) -> 404:double, DoubleColDivideLongColumn(col 407:double, col 410:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 406:double)(children: DoubleColDivideLongColumn(col 405:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 405:double) -> 406:double) -> 407:double, IfExprNullCondExpr(col 408:boolean, null, col 409:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 408:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 409:bigint) -> 410:bigint) -> 411:double, DoubleColAddDoubleColumn(col 418:double, col 434:double)(children: DoubleColDivideLongColumn(col 414:double, col 417:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 413:double)(children: DoubleColDivideLongColumn(col 412:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 412:double) -> 413:double) -> 414:double, IfExprNullCondExpr(col 415:boolean, null, col 416:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 415:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 416:bigint) -> 417:bigint) -> 418:double, DoubleColMultiplyDoubleColumn(col 431:double, col 433:double)(children: DoubleColMultiplyDoubleColumn(col 424:double, col 430:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 423:double)(children: FuncPowerDoubleToDouble(col 422:double)(children: DoubleColDivideLongColumn(col 421:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 420:double)(children: DoubleColDivideLongColumn(col 419:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 419:double) -> 420:double) -> 421:double) -> 422:double) -> 423:double) -> 424:double, DoubleColUnaryMinus(col 429:double)(children: FuncPowerDoubleToDouble(col 428:double)(children: DoubleColDivideLongColumn(col 427:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 426:double)(children: DoubleColDivideLongColumn(col 425:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 425:double) -> 426:double) -> 427:double) -> 428:double) -> 429:double) -> 430:double) -> 431:double, CastLongToDouble(col 432:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 432:bigint) -> 433:double) -> 434:double) -> 435:double, DoubleColUnaryMinus(col 441:double)(children: DoubleColUnaryMinus(col 440:double)(children: FuncPowerDoubleToDouble(col 439:double)(children: DoubleColDivideLongColumn(col 438:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 437:double)(children: DoubleColDivideLongColumn(col 436:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 436:double) -> 437:double) -> 438:double) -> 439:double) -> 440:double) -> 441:double) -> 442:double, DoubleColDivideDoubleColumn(col 444:double, col 449:double)(children: CastLongToDouble(col 443:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 443:bigint) -> 444:double, FuncPowerDoubleToDouble(col 448:double)(children: DoubleColDivideLongColumn(col 447:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 446:double)(children: DoubleColDivideLongColumn(col 445:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 445:double) -> 446:double) -> 447:double) -> 448:double) -> 449:double) -> 450:double, DoubleColDivideLongColumn(col 453:double, col 13:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 452:double)(children: DoubleColDivideLongColumn(col 451:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 451:double) -> 452:double) -> 453:double) -> 454:double, DoubleScalarDivideDoubleColumn(val 10.175, col 456:double)(children: DoubleColDivideLongColumn(col 455:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 455:double) -> 456:double) -> 457:double, DoubleColDivideLongColumn(col 458:double, col 4:bigint)(children: CastLongToDouble(col 14:bigint) -> 458:double) -> 459:double, DoubleColDivideLongColumn(col 462:double, col 465:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 461:double)(children: DoubleColDivideLongColumn(col 460:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 460:double) -> 461:double) -> 462:double, IfExprNullCondExpr(col 463:boolean, null, col 464:bigint)(children: LongColEqualLongScalar(col 13:bigint, val 1) -> 463:boolean, LongColSubtractLongScalar(col 13:bigint, val 1) -> 464:bigint) -> 465:bigint) -> 466:double, DoubleColSubtractDoubleColumn(col 490:double, col 506:double)(children: DoubleColAddDoubleColumn(col 473:double, col 489:double)(children: DoubleColDivideLongColumn(col 469:double, col 472:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 468:double)(children: DoubleColDivideLongColumn(col 467:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 467:double) -> 468:double) -> 469:double, IfExprNullCondExpr(col 470:boolean, null, col 471:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 470:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 471:bigint) -> 472:bigint) -> 473:double, DoubleColMultiplyDoubleColumn(col 486:double, col 488:double)(children: DoubleColMultiplyDoubleColumn(col 479:double, col 485:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 478:double)(children: FuncPowerDoubleToDouble(col 477:double)(children: DoubleColDivideLongColumn(col 476:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 475:double)(children: DoubleColDivideLongColumn(col 474:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 474:double) -> 475:double) -> 476:double) -> 477:double) -> 478:double) -> 479:double, DoubleColUnaryMinus(col 484:double)(children: FuncPowerDoubleToDouble(col 483:double)(children: DoubleColDivideLongColumn(col 482:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 481:double)(children: DoubleColDivideLongColumn(col 480:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 480:double) -> 481:double) -> 482:double) -> 483:double) -> 484:double) -> 485:double) -> 486:double, CastLongToDouble(col 487:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 487:bigint) -> 488:double) -> 489:double) -> 490:double, DoubleColMultiplyDoubleColumn(col 503:double, col 505:double)(children: DoubleColMultiplyDoubleColumn(col 496:double, col 502:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 495:double)(children: FuncPowerDoubleToDouble(col 494:double)(children: DoubleColDivideLongColumn(col 493:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 492:double)(children: DoubleColDivideLongColumn(col 491:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 491:double) -> 492:double) -> 493:double) -> 494:double) -> 495:double) -> 496:double, DoubleColUnaryMinus(col 501:double)(children: FuncPowerDoubleToDouble(col 500:double)(children: DoubleColDivideLongColumn(col 499:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 498:double)(children: DoubleColDivideLongColumn(col 497:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 497:double) -> 498:double) -> 499:double) -> 500:double) -> 501:double) -> 502:double) -> 503:double, CastLongToDouble(col 504:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 504:bigint) -> 505:double) -> 506:double) -> 507:double, DoubleColUnaryMinus(col 514:double)(children: DoubleColUnaryMinus(col 513:double)(children: DoubleColMultiplyDoubleScalar(col 512:double, val 10.175)(children: FuncPowerDoubleToDouble(col 511:double)(children: DoubleColDivideLongColumn(col 510:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 509:double)(children: DoubleColDivideLongColumn(col 508:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 508:double) -> 509:double) -> 510:double) -> 511:double) -> 512:double) -> 513:double) -> 514:double) -> 515:double, DoubleColDivideLongColumn(col 15:double, col 13:bigint) -> 516:double, DoubleColMultiplyDoubleScalar(col 557:double, val 10.175)(children: DoubleColSubtractDoubleColumn(col 540:double, col 556:double)(children: DoubleColAddDoubleColumn(col 523:double, col 539:double)(children: DoubleColDivideLongColumn(col 519:double, col 522:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 518:double)(children: DoubleColDivideLongColumn(col 517:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 517:double) -> 518:double) -> 519:double, IfExprNullCondExpr(col 520:boolean, null, col 521:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 520:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 521:bigint) -> 522:bigint) -> 523:double, DoubleColMultiplyDoubleColumn(col 536:double, col 538:double)(children: DoubleColMultiplyDoubleColumn(col 529:double, col 535:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 528:double)(children: FuncPowerDoubleToDouble(col 527:double)(children: DoubleColDivideLongColumn(col 526:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 525:double)(children: DoubleColDivideLongColumn(col 524:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 524:double) -> 525:double) -> 526:double) -> 527:double) -> 528:double) -> 529:double, DoubleColUnaryMinus(col 534:double)(children: FuncPowerDoubleToDouble(col 533:double)(children: DoubleColDivideLongColumn(col 532:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 531:double)(children: DoubleColDivideLongColumn(col 530:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 530:double) -> 531:double) -> 532:double) -> 533:double) -> 534:double) -> 535:double) -> 536:double, CastLongToDouble(col 537:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 537:bigint) -> 538:double) -> 539:double) -> 540:double, DoubleColMultiplyDoubleColumn(col 553:double, col 555:double)(children: DoubleColMultiplyDoubleColumn(col 546:double, col 552:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 545:double)(children: FuncPowerDoubleToDouble(col 544:double)(children: DoubleColDivideLongColumn(col 543:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 542:double)(children: DoubleColDivideLongColumn(col 541:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 541:double) -> 542:double) -> 543:double) -> 544:double) -> 545:double) -> 546:double, DoubleColUnaryMinus(col 551:double)(children: FuncPowerDoubleToDouble(col 550:double)(children: DoubleColDivideLongColumn(col 549:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 548:double)(children: DoubleColDivideLongColumn(col 547:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 547:double) -> 548:double) -> 549:double) -> 550:double) -> 551:double) -> 552:double) -> 553:double, CastLongToDouble(col 554:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 554:bigint) -> 555:double) -> 556:double) -> 557:double) -> 558:double, DoubleScalarModuloDoubleColumn(val 10.175, col 561:double)(children: DoubleScalarDivideDoubleColumn(val 10.175, col 560:double)(children: DoubleColDivideLongColumn(col 559:double, col 6:bigint)(children: CastLongToDouble(col 5:bigint) -> 559:double) -> 560:double) -> 561:double) -> 562:double, LongColUnaryMinus(col 8:tinyint) -> 563:tinyint, DoubleColDivideLongColumn(col 566:double, col 6:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 565:double)(children: DoubleColDivideLongColumn(col 564:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 564:double) -> 565:double) -> 566:double) -> 567:double, DoubleColUnaryMinus(col 580:double)(children: DoubleColMultiplyDoubleColumn(col 573:double, col 579:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 572:double)(children: FuncPowerDoubleToDouble(col 571:double)(children: DoubleColDivideLongColumn(col 570:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 569:double)(children: DoubleColDivideLongColumn(col 568:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 568:double) -> 569:double) -> 570:double) -> 571:double) -> 572:double) -> 573:double, DoubleColUnaryMinus(col 578:double)(children: FuncPowerDoubleToDouble(col 577:double)(children: DoubleColDivideLongColumn(col 576:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 575:double)(children: DoubleColDivideLongColumn(col 574:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 574:double) -> 575:double) -> 576:double) -> 577:double) -> 578:double) -> 579:double) -> 580:double) -> 581:double, DoubleColModuloDoubleColumn(col 587:double, col 588:double)(children: DoubleColUnaryMinus(col 586:double)(children: FuncPowerDoubleToDouble(col 585:double)(children: DoubleColDivideLongColumn(col 584:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 583:double)(children: DoubleColDivideLongColumn(col 582:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 582:double) -> 583:double) -> 584:double) -> 585:double) -> 586:double) -> 587:double, DoubleColDivideLongColumn(col 15:double, col 13:bigint) -> 588:double) -> 589:double, DecimalScalarDivideDecimalColumn(val -26.28, col 591:decimal(3,0))(children: CastLongToDecimal(col 590:tinyint)(children: LongColUnaryMinus(col 8:tinyint) -> 590:tinyint) -> 591:decimal(3,0)) -> 592:decimal(8,6), FuncPowerDoubleToDouble(col 596:double)(children: DoubleColDivideLongColumn(col 595:double, col 19:bigint)(children: DoubleColSubtractDoubleColumn(col 17:double, col 594:double)(children: DoubleColDivideLongColumn(col 593:double, col 19:bigint)(children: DoubleColMultiplyDoubleColumn(col 18:double, col 18:double) -> 593:double) -> 594:double) -> 595:double) -> 596:double) -> 597:double, DoubleColDivideDoubleColumn(col 621:double, col 625:double)(children: DoubleColAddDoubleColumn(col 604:double, col 620:double)(children: DoubleColDivideLongColumn(col 600:double, col 603:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 599:double)(children: DoubleColDivideLongColumn(col 598:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 598:double) -> 599:double) -> 600:double, IfExprNullCondExpr(col 601:boolean, null, col 602:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 601:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 602:bigint) -> 603:bigint) -> 604:double, DoubleColMultiplyDoubleColumn(col 617:double, col 619:double)(children: DoubleColMultiplyDoubleColumn(col 610:double, col 616:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 609:double)(children: FuncPowerDoubleToDouble(col 608:double)(children: DoubleColDivideLongColumn(col 607:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 606:double)(children: DoubleColDivideLongColumn(col 605:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 605:double) -> 606:double) -> 607:double) -> 608:double) -> 609:double) -> 610:double, DoubleColUnaryMinus(col 615:double)(children: FuncPowerDoubleToDouble(col 614:double)(children: DoubleColDivideLongColumn(col 613:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 612:double)(children: DoubleColDivideLongColumn(col 611:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 611:double) -> 612:double) -> 613:double) -> 614:double) -> 615:double) -> 616:double) -> 617:double, CastLongToDouble(col 618:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 618:bigint) -> 619:double) -> 620:double) -> 621:double, DoubleColDivideLongColumn(col 624:double, col 13:bigint)(children: DoubleColSubtractDoubleColumn(col 11:double, col 623:double)(children: DoubleColDivideLongColumn(col 622:double, col 13:bigint)(children: DoubleColMultiplyDoubleColumn(col 12:double, col 12:double) -> 622:double) -> 623:double) -> 624:double) -> 625:double) -> 626:double, LongColUnaryMinus(col 627:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 627:bigint) -> 628:bigint, DoubleColModuloDoubleScalar(col 652:double, val -26.28)(children: DoubleColAddDoubleColumn(col 635:double, col 651:double)(children: DoubleColDivideLongColumn(col 631:double, col 634:bigint)(children: DoubleColSubtractDoubleColumn(col 9:double, col 630:double)(children: DoubleColDivideLongColumn(col 629:double, col 6:bigint)(children: DoubleColMultiplyDoubleColumn(col 10:double, col 10:double) -> 629:double) -> 630:double) -> 631:double, IfExprNullCondExpr(col 632:boolean, null, col 633:bigint)(children: LongColEqualLongScalar(col 6:bigint, val 1) -> 632:boolean, LongColSubtractLongScalar(col 6:bigint, val 1) -> 633:bigint) -> 634:bigint) -> 635:double, DoubleColMultiplyDoubleColumn(col 648:double, col 650:double)(children: DoubleColMultiplyDoubleColumn(col 641:double, col 647:double)(children: DoubleScalarSubtractDoubleColumn(val -26.28, col 640:double)(children: FuncPowerDoubleToDouble(col 639:double)(children: DoubleColDivideLongColumn(col 638:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 637:double)(children: DoubleColDivideLongColumn(col 636:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 636:double) -> 637:double) -> 638:double) -> 639:double) -> 640:double) -> 641:double, DoubleColUnaryMinus(col 646:double)(children: FuncPowerDoubleToDouble(col 645:double)(children: DoubleColDivideLongColumn(col 644:double, col 4:bigint)(children: DoubleColSubtractDoubleColumn(col 2:double, col 643:double)(children: DoubleColDivideLongColumn(col 642:double, col 4:bigint)(children: DoubleColMultiplyDoubleColumn(col 3:double, col 3:double) -> 642:double) -> 643:double) -> 644:double) -> 645:double) -> 646:double) -> 647:double) -> 648:double, CastLongToDouble(col 649:bigint)(children: LongColUnaryMinus(col 7:bigint) -> 649:bigint) -> 650:double) -> 651:double) -> 652:double) -> 653:double + Statistics: Num rows: 5980 Data size: 2333414 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: timestamp), _col1 (type: string), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: bigint), _col9 (type: bigint), _col10 (type: double), _col11 (type: tinyint), _col12 (type: double), _col13 (type: double), _col14 (type: double), _col15 (type: double), _col16 (type: double), _col17 (type: double), _col18 (type: double), _col19 (type: double), _col20 (type: double), _col21 (type: double), _col22 (type: double), _col23 (type: double), _col24 (type: double), _col25 (type: double), _col26 (type: double), _col27 (type: tinyint), _col28 (type: double), _col29 (type: double), _col30 (type: double), _col31 (type: double), _col32 (type: decimal(8,6)), _col33 (type: double), _col34 (type: bigint), _col35 (type: double), _col36 (type: bigint), _col37 (type: bigint), _col38 (type: double) + null sort order: zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz + sort order: +++++++++++++++++++++++++++++++++++++++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 5980 Data size: 2333414 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -2960,19 +3040,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumnNums: [0, 1, 2, 3, 4, 5, 4, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 8, 38] - Statistics: Num rows: 5980 Data size: 2942564 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5980 Data size: 2333414 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 50 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 50 Data size: 24692 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 50 Data size: 19734 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 50 Data size: 24692 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 50 Data size: 19734 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat diff --git ql/src/test/results/clientpositive/perf/tez/cbo_query14.q.out ql/src/test/results/clientpositive/perf/tez/cbo_query14.q.out index e9308cd709..d1e8c3806e 100644 --- ql/src/test/results/clientpositive/perf/tez/cbo_query14.q.out +++ ql/src/test/results/clientpositive/perf/tez/cbo_query14.q.out @@ -1,6 +1,6 @@ -Warning: Shuffle Join MERGEJOIN[1173][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product -Warning: Shuffle Join MERGEJOIN[1180][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product -Warning: Shuffle Join MERGEJOIN[1187][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product +Warning: Shuffle Join MERGEJOIN[1175][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product +Warning: Shuffle Join MERGEJOIN[1182][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[1189][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product PREHOOK: query: explain cbo with cross_items as (select i_item_sk ss_item_sk diff --git ql/src/test/results/clientpositive/perf/tez/cbo_query54.q.out ql/src/test/results/clientpositive/perf/tez/cbo_query54.q.out index e96d4c60a6..d7056cb2d3 100644 --- ql/src/test/results/clientpositive/perf/tez/cbo_query54.q.out +++ ql/src/test/results/clientpositive/perf/tez/cbo_query54.q.out @@ -1,7 +1,7 @@ -Warning: Shuffle Join MERGEJOIN[269][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product -Warning: Shuffle Join MERGEJOIN[270][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4]] in Stage 'Reducer 5' is a cross product -Warning: Shuffle Join MERGEJOIN[271][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 6' is a cross product -Warning: Shuffle Join MERGEJOIN[272][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 7' is a cross product +Warning: Shuffle Join MERGEJOIN[271][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product +Warning: Shuffle Join MERGEJOIN[272][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4]] in Stage 'Reducer 5' is a cross product +Warning: Shuffle Join MERGEJOIN[273][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 6' is a cross product +Warning: Shuffle Join MERGEJOIN[274][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 7' is a cross product PREHOOK: query: explain cbo with my_customers as ( select distinct c_customer_sk diff --git ql/src/test/results/clientpositive/perf/tez/cbo_query58.q.out ql/src/test/results/clientpositive/perf/tez/cbo_query58.q.out index 523f02e7d7..52e9e79860 100644 --- ql/src/test/results/clientpositive/perf/tez/cbo_query58.q.out +++ ql/src/test/results/clientpositive/perf/tez/cbo_query58.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[404][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 22' is a cross product +Warning: Shuffle Join MERGEJOIN[405][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 22' is a cross product PREHOOK: query: explain cbo with ss_items as (select i_item_id item_id diff --git ql/src/test/results/clientpositive/perf/tez/cbo_query6.q.out ql/src/test/results/clientpositive/perf/tez/cbo_query6.q.out index 944b113e7b..19410a8876 100644 --- ql/src/test/results/clientpositive/perf/tez/cbo_query6.q.out +++ ql/src/test/results/clientpositive/perf/tez/cbo_query6.q.out @@ -1,4 +1,4 @@ -Warning: Map Join MAPJOIN[172][bigTable=?] in task 'Reducer 15' is a cross product +Warning: Map Join MAPJOIN[173][bigTable=?] in task 'Reducer 15' is a cross product PREHOOK: query: explain cbo select a.ca_state state, count(*) cnt from customer_address a diff --git ql/src/test/results/clientpositive/perf/tez/cbo_query77.q.out ql/src/test/results/clientpositive/perf/tez/cbo_query77.q.out index 02caf99f7d..aa080603e1 100644 --- ql/src/test/results/clientpositive/perf/tez/cbo_query77.q.out +++ ql/src/test/results/clientpositive/perf/tez/cbo_query77.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[317][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[319][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product PREHOOK: query: explain cbo with ss as (select s_store_sk, diff --git ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query14.q.out ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query14.q.out index 43e1b2b5c2..59fcf951fe 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query14.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query14.q.out @@ -1,6 +1,6 @@ -Warning: Shuffle Join MERGEJOIN[1191][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product -Warning: Shuffle Join MERGEJOIN[1198][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product -Warning: Shuffle Join MERGEJOIN[1205][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product +Warning: Shuffle Join MERGEJOIN[1193][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product +Warning: Shuffle Join MERGEJOIN[1200][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[1207][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product PREHOOK: query: explain cbo with cross_items as (select i_item_sk ss_item_sk diff --git ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query54.q.out ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query54.q.out index ece76c3e4e..6aceb4b61e 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query54.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query54.q.out @@ -1,7 +1,7 @@ -Warning: Shuffle Join MERGEJOIN[275][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product -Warning: Shuffle Join MERGEJOIN[281][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product -Warning: Shuffle Join MERGEJOIN[280][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 15' is a cross product -Warning: Shuffle Join MERGEJOIN[283][tables = [$hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[277][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[283][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[282][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 15' is a cross product +Warning: Shuffle Join MERGEJOIN[285][tables = [$hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 16' is a cross product PREHOOK: query: explain cbo with my_customers as ( select distinct c_customer_sk diff --git ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query58.q.out ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query58.q.out index 954bdc4dd1..f26eae0acc 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query58.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query58.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[406][tables = [$hdt$_3, $hdt$_4]] in Stage 'Reducer 20' is a cross product +Warning: Shuffle Join MERGEJOIN[407][tables = [$hdt$_3, $hdt$_4]] in Stage 'Reducer 20' is a cross product PREHOOK: query: explain cbo with ss_items as (select i_item_id item_id diff --git ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query6.q.out ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query6.q.out index eb872d7e6d..c2151f9b91 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query6.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query6.q.out @@ -1,4 +1,4 @@ -Warning: Map Join MAPJOIN[169][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[170][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: explain cbo select a.ca_state state, count(*) cnt from customer_address a diff --git ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query77.q.out ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query77.q.out index 2f75361df1..39da7ea903 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query77.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/cbo_query77.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[225][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 14' is a cross product +Warning: Shuffle Join MERGEJOIN[227][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 14' is a cross product PREHOOK: query: explain cbo with ss as (select s_store_sk, diff --git ql/src/test/results/clientpositive/perf/tez/constraints/mv_query44.q.out ql/src/test/results/clientpositive/perf/tez/constraints/mv_query44.q.out index a546472908..786bbe12c8 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/mv_query44.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/mv_query44.q.out @@ -19,7 +19,7 @@ POSTHOOK: type: CREATE_MATERIALIZED_VIEW POSTHOOK: Input: default@store_sales POSTHOOK: Output: database:default POSTHOOK: Output: default@mv_store_sales_item_customer -Warning: Shuffle Join MERGEJOIN[109][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[110][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product PREHOOK: query: explain select asceding.rnk, i1.i_product_name best_performing, i2.i_product_name worst_performing from(select * @@ -112,109 +112,111 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_146] - Limit [LIM_145] (rows=100 width=218) + File Output Operator [FS_147] + Limit [LIM_146] (rows=100 width=218) Number of rows:100 - Select Operator [SEL_144] (rows=6951 width=218) + Select Operator [SEL_145] (rows=6951 width=218) Output:["_col0","_col1","_col2"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_70] Select Operator [SEL_69] (rows=6951 width=218) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_113] (rows=6951 width=218) - Conds:RS_66._col2=RS_143._col0(Inner),Output:["_col1","_col5","_col7"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_143] - PartitionCols:_col0 - Select Operator [SEL_141] (rows=462000 width=111) - Output:["_col0","_col1"] - TableScan [TS_56] (rows=462000 width=111) - default@item,i1,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_product_name"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_112] (rows=6951 width=115) - Conds:RS_63._col0=RS_142._col0(Inner),Output:["_col1","_col2","_col5"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_142] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_141] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_111] (rows=6951 width=12) - Conds:RS_135._col1=RS_140._col1(Inner),Output:["_col0","_col1","_col2"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_135] - PartitionCols:_col1 - Select Operator [SEL_134] (rows=6951 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_133] (rows=6951 width=116) - predicate:(rank_window_0 < 11) - PTF Operator [PTF_132] (rows=20854 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_131] (rows=20854 width=116) - Output:["_col0","_col1"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:0 - Filter Operator [FIL_20] (rows=20854 width=228) - predicate:(_col1 > (0.9 * _col2)) - Merge Join Operator [MERGEJOIN_109] (rows=62562 width=228) - Conds:(Inner),Output:["_col0","_col1","_col2"] - <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_130] - Select Operator [SEL_129] (rows=1 width=112) - Output:["_col0"] - Filter Operator [FIL_128] (rows=1 width=120) - predicate:(_col1 is not null and _col2 is not null) - Select Operator [SEL_127] (rows=1 width=120) - Output:["_col1","_col2"] - Group By Operator [GBY_126] (rows=1 width=124) + Top N Key Operator [TNK_99] (rows=6951 width=218) + keys:_col1,top n:100 + Merge Join Operator [MERGEJOIN_114] (rows=6951 width=218) + Conds:RS_66._col2=RS_144._col0(Inner),Output:["_col1","_col5","_col7"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_144] + PartitionCols:_col0 + Select Operator [SEL_142] (rows=462000 width=111) + Output:["_col0","_col1"] + TableScan [TS_56] (rows=462000 width=111) + default@item,i1,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_product_name"] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_113] (rows=6951 width=115) + Conds:RS_63._col0=RS_143._col0(Inner),Output:["_col1","_col2","_col5"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_143] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_142] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_112] (rows=6951 width=12) + Conds:RS_136._col1=RS_141._col1(Inner),Output:["_col0","_col1","_col2"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_136] + PartitionCols:_col1 + Select Operator [SEL_135] (rows=6951 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_134] (rows=6951 width=116) + predicate:(rank_window_0 < 11) + PTF Operator [PTF_133] (rows=20854 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"0"}] + Select Operator [SEL_132] (rows=20854 width=116) + Output:["_col0","_col1"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:0 + Filter Operator [FIL_20] (rows=20854 width=228) + predicate:(_col1 > (0.9 * _col2)) + Merge Join Operator [MERGEJOIN_110] (rows=62562 width=228) + Conds:(Inner),Output:["_col0","_col1","_col2"] + <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_131] + Select Operator [SEL_130] (rows=1 width=112) + Output:["_col0"] + Filter Operator [FIL_129] (rows=1 width=120) + predicate:(_col1 is not null and _col2 is not null) + Select Operator [SEL_128] (rows=1 width=120) + Output:["_col1","_col2"] + Group By Operator [GBY_127] (rows=1 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_126] + PartitionCols:_col0 + Group By Operator [GBY_125] (rows=258 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","count(_col1)"],keys:true + Select Operator [SEL_124] (rows=287946 width=114) + Output:["_col1"] + Filter Operator [FIL_123] (rows=287946 width=114) + predicate:(ss_hdemo_sk is null and (ss_store_sk = 410)) + TableScan [TS_8] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_hdemo_sk","ss_store_sk","ss_net_profit"] + <-Reducer 2 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_122] + Select Operator [SEL_121] (rows=62562 width=116) + Output:["_col0","_col1"] + Filter Operator [FIL_120] (rows=62562 width=124) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_119] (rows=62562 width=124) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_125] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_118] PartitionCols:_col0 - Group By Operator [GBY_124] (rows=258 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","count(_col1)"],keys:true - Select Operator [SEL_123] (rows=287946 width=114) - Output:["_col1"] - Filter Operator [FIL_122] (rows=287946 width=114) - predicate:(ss_hdemo_sk is null and (ss_store_sk = 410)) - TableScan [TS_8] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_hdemo_sk","ss_store_sk","ss_net_profit"] - <-Reducer 2 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_121] - Select Operator [SEL_120] (rows=62562 width=116) - Output:["_col0","_col1"] - Filter Operator [FIL_119] (rows=62562 width=124) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_118] (rows=62562 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] - PartitionCols:_col0 - Group By Operator [GBY_116] (rows=3199976 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(ss_net_profit)","count(ss_net_profit)"],keys:ss_item_sk - Select Operator [SEL_115] (rows=6399952 width=114) - Output:["ss_item_sk","ss_net_profit"] - Filter Operator [FIL_114] (rows=6399952 width=114) - predicate:(ss_store_sk = 410) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,ss1,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_store_sk","ss_net_profit"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_140] - PartitionCols:_col1 - Select Operator [SEL_139] (rows=6951 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_138] (rows=6951 width=116) - predicate:(rank_window_0 < 11) - PTF Operator [PTF_137] (rows=20854 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_136] (rows=20854 width=116) - Output:["_col0","_col1"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_49] - PartitionCols:0 - Please refer to the previous Filter Operator [FIL_20] + Group By Operator [GBY_117] (rows=3199976 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(ss_net_profit)","count(ss_net_profit)"],keys:ss_item_sk + Select Operator [SEL_116] (rows=6399952 width=114) + Output:["ss_item_sk","ss_net_profit"] + Filter Operator [FIL_115] (rows=6399952 width=114) + predicate:(ss_store_sk = 410) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,ss1,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_store_sk","ss_net_profit"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_141] + PartitionCols:_col1 + Select Operator [SEL_140] (rows=6951 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_139] (rows=6951 width=116) + predicate:(rank_window_0 < 11) + PTF Operator [PTF_138] (rows=20854 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"0"}] + Select Operator [SEL_137] (rows=20854 width=116) + Output:["_col0","_col1"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_49] + PartitionCols:0 + Please refer to the previous Filter Operator [FIL_20] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query1.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query1.q.out index 3aea12dda6..6358930eee 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query1.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query1.q.out @@ -73,109 +73,111 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_164] - Limit [LIM_163] (rows=100 width=100) + File Output Operator [FS_165] + Limit [LIM_164] (rows=100 width=100) Number of rows:100 - Select Operator [SEL_162] (rows=17457727 width=100) + Select Operator [SEL_163] (rows=17457727 width=100) Output:["_col0"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_51] Select Operator [SEL_50] (rows=17457727 width=100) Output:["_col0"] - Merge Join Operator [MERGEJOIN_136] (rows=17457727 width=100) - Conds:RS_47._col1=RS_161._col0(Inner),Output:["_col7"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_161] - PartitionCols:_col0 - Select Operator [SEL_160] (rows=80000000 width=104) - Output:["_col0","_col1"] - TableScan [TS_38] (rows=80000000 width=104) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_47] - PartitionCols:_col1 - Filter Operator [FIL_46] (rows=17457727 width=227) - predicate:(_col3 > _col4) - Merge Join Operator [MERGEJOIN_135] (rows=52373181 width=227) - Conds:RS_43._col2=RS_159._col1(Inner),Output:["_col1","_col3","_col4"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_159] - PartitionCols:_col1 - Select Operator [SEL_158] (rows=85 width=115) - Output:["_col0","_col1"] - Filter Operator [FIL_157] (rows=85 width=123) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_156] (rows=85 width=123) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 - Select Operator [SEL_155] (rows=53634860 width=119) - Output:["_col1","_col2"] - Group By Operator [GBY_154] (rows=53634860 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col0 - Group By Operator [GBY_28] (rows=53634860 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_134] (rows=53634860 width=115) - Conds:RS_145._col0=RS_149._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_149] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_146] (rows=652 width=8) - predicate:(d_year = 2000) - TableScan [TS_6] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_145] - PartitionCols:_col0 - Select Operator [SEL_143] (rows=53634860 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_141] (rows=53634860 width=119) - predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) - TableScan [TS_3] (rows=57591150 width=119) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_customer_sk","sr_store_sk","sr_fee"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_43] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_133] (rows=51757026 width=119) - Conds:RS_139._col0=RS_153._col1(Inner),Output:["_col1","_col2","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_139] - PartitionCols:_col0 - Select Operator [SEL_138] (rows=35 width=4) - Output:["_col0"] - Filter Operator [FIL_137] (rows=35 width=90) - predicate:(s_state = 'NM') - TableScan [TS_0] (rows=1704 width=90) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_153] - PartitionCols:_col1 - Select Operator [SEL_152] (rows=51757026 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_151] (rows=51757026 width=119) - predicate:_col2 is not null - Group By Operator [GBY_150] (rows=51757026 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_14] - PartitionCols:_col0, _col1 - Group By Operator [GBY_13] (rows=51757026 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_132] (rows=51757026 width=115) - Conds:RS_144._col0=RS_148._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_147] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] - PartitionCols:_col0 - Select Operator [SEL_142] (rows=51757026 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_140] (rows=51757026 width=119) - predicate:(sr_customer_sk is not null and sr_store_sk is not null and sr_returned_date_sk is not null) - Please refer to the previous TableScan [TS_3] + Top N Key Operator [TNK_79] (rows=17457727 width=100) + keys:_col7,top n:100 + Merge Join Operator [MERGEJOIN_137] (rows=17457727 width=100) + Conds:RS_47._col1=RS_162._col0(Inner),Output:["_col7"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_162] + PartitionCols:_col0 + Select Operator [SEL_161] (rows=80000000 width=104) + Output:["_col0","_col1"] + TableScan [TS_38] (rows=80000000 width=104) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_47] + PartitionCols:_col1 + Filter Operator [FIL_46] (rows=17457727 width=227) + predicate:(_col3 > _col4) + Merge Join Operator [MERGEJOIN_136] (rows=52373181 width=227) + Conds:RS_43._col2=RS_160._col1(Inner),Output:["_col1","_col3","_col4"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_160] + PartitionCols:_col1 + Select Operator [SEL_159] (rows=85 width=115) + Output:["_col0","_col1"] + Filter Operator [FIL_158] (rows=85 width=123) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_157] (rows=85 width=123) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 + Select Operator [SEL_156] (rows=53634860 width=119) + Output:["_col1","_col2"] + Group By Operator [GBY_155] (rows=53634860 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col0 + Group By Operator [GBY_28] (rows=53634860 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_135] (rows=53634860 width=115) + Conds:RS_146._col0=RS_150._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_150] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_147] (rows=652 width=8) + predicate:(d_year = 2000) + TableScan [TS_6] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_146] + PartitionCols:_col0 + Select Operator [SEL_144] (rows=53634860 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_142] (rows=53634860 width=119) + predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) + TableScan [TS_3] (rows=57591150 width=119) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_customer_sk","sr_store_sk","sr_fee"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_134] (rows=51757026 width=119) + Conds:RS_140._col0=RS_154._col1(Inner),Output:["_col1","_col2","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_140] + PartitionCols:_col0 + Select Operator [SEL_139] (rows=35 width=4) + Output:["_col0"] + Filter Operator [FIL_138] (rows=35 width=90) + predicate:(s_state = 'NM') + TableScan [TS_0] (rows=1704 width=90) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_154] + PartitionCols:_col1 + Select Operator [SEL_153] (rows=51757026 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_152] (rows=51757026 width=119) + predicate:_col2 is not null + Group By Operator [GBY_151] (rows=51757026 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_14] + PartitionCols:_col0, _col1 + Group By Operator [GBY_13] (rows=51757026 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_133] (rows=51757026 width=115) + Conds:RS_145._col0=RS_149._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_148] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_145] + PartitionCols:_col0 + Select Operator [SEL_143] (rows=51757026 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_141] (rows=51757026 width=119) + predicate:(sr_customer_sk is not null and sr_store_sk is not null and sr_returned_date_sk is not null) + Please refer to the previous TableScan [TS_3] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query10.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query10.q.out index bb3b1b6660..d245a60587 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query10.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query10.q.out @@ -157,120 +157,120 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_229] - Limit [LIM_228] (rows=1 width=419) + File Output Operator [FS_234] + Limit [LIM_233] (rows=1 width=419) Number of rows:100 - Select Operator [SEL_227] (rows=1 width=419) + Select Operator [SEL_232] (rows=1 width=419) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_226] - Select Operator [SEL_225] (rows=1 width=419) + SHUFFLE [RS_231] + Select Operator [SEL_230] (rows=1 width=419) Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col8","_col10","_col12"] - Group By Operator [GBY_224] (rows=1 width=379) + Group By Operator [GBY_229] (rows=1 width=379) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Group By Operator [GBY_65] (rows=3 width=379) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["count()"],keys:_col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Top N Key Operator [TNK_102] (rows=1401496 width=379) - keys:_col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13,top n:100 - Select Operator [SEL_64] (rows=1401496 width=379) - Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Select Operator [SEL_64] (rows=1401496 width=379) + Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Top N Key Operator [TNK_105] (rows=1401496 width=379) + keys:_col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13,top n:100 Filter Operator [FIL_63] (rows=1401496 width=379) predicate:(_col14 is not null or _col16 is not null) - Merge Join Operator [MERGEJOIN_180] (rows=1401496 width=379) - Conds:RS_60._col0=RS_223._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col16"] + Merge Join Operator [MERGEJOIN_185] (rows=1401496 width=379) + Conds:RS_60._col0=RS_228._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col16"] <-Reducer 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] + SHUFFLE [RS_228] PartitionCols:_col1 - Select Operator [SEL_222] (rows=1401496 width=7) + Select Operator [SEL_227] (rows=1401496 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_221] (rows=1401496 width=3) + Group By Operator [GBY_226] (rows=1401496 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 18 [SIMPLE_EDGE] SHUFFLE [RS_43] PartitionCols:_col0 Group By Operator [GBY_42] (rows=285115246 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_177] (rows=285115246 width=3) - Conds:RS_220._col0=RS_195._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_182] (rows=285115246 width=3) + Conds:RS_225._col0=RS_200._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_195] + PARTITION_ONLY_SHUFFLE [RS_200] PartitionCols:_col0 - Select Operator [SEL_190] (rows=201 width=4) + Select Operator [SEL_195] (rows=201 width=4) Output:["_col0"] - Filter Operator [FIL_189] (rows=201 width=12) + Filter Operator [FIL_194] (rows=201 width=12) predicate:((d_year = 2002) and d_moy BETWEEN 4 AND 7) TableScan [TS_11] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_220] + SHUFFLE [RS_225] PartitionCols:_col0 - Select Operator [SEL_219] (rows=285115246 width=7) + Select Operator [SEL_224] (rows=285115246 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_218] (rows=285115246 width=7) + Filter Operator [FIL_223] (rows=285115246 width=7) predicate:(cs_ship_customer_sk is not null and cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_39_date_dim_d_date_sk_min) AND DynamicValue(RS_39_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_39_date_dim_d_date_sk_bloom_filter))) TableScan [TS_32] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"] <-Reducer 20 [BROADCAST_EDGE] vectorized - BROADCAST [RS_217] - Group By Operator [GBY_216] (rows=1 width=12) + BROADCAST [RS_222] + Group By Operator [GBY_221] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_202] - Group By Operator [GBY_199] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_207] + Group By Operator [GBY_204] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_196] (rows=201 width=4) + Select Operator [SEL_201] (rows=201 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_179] (rows=1414922 width=379) - Conds:RS_57._col0=RS_215._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] + Merge Join Operator [MERGEJOIN_184] (rows=1414922 width=379) + Conds:RS_57._col0=RS_220._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_215] + SHUFFLE [RS_220] PartitionCols:_col1 - Select Operator [SEL_214] (rows=1414922 width=7) + Select Operator [SEL_219] (rows=1414922 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_213] (rows=1414922 width=3) + Group By Operator [GBY_218] (rows=1414922 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 Group By Operator [GBY_28] (rows=143930993 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_176] (rows=143930993 width=3) - Conds:RS_212._col0=RS_193._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_181] (rows=143930993 width=3) + Conds:RS_217._col0=RS_198._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_193] + PARTITION_ONLY_SHUFFLE [RS_198] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_212] + SHUFFLE [RS_217] PartitionCols:_col0 - Select Operator [SEL_211] (rows=143930993 width=7) + Select Operator [SEL_216] (rows=143930993 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_210] (rows=143930993 width=7) + Filter Operator [FIL_215] (rows=143930993 width=7) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_25_date_dim_d_date_sk_min) AND DynamicValue(RS_25_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_25_date_dim_d_date_sk_bloom_filter))) TableScan [TS_18] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"] <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_209] - Group By Operator [GBY_208] (rows=1 width=12) + BROADCAST [RS_214] + Group By Operator [GBY_213] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_201] - Group By Operator [GBY_198] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_206] + Group By Operator [GBY_203] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_194] (rows=201 width=4) + Select Operator [SEL_199] (rows=201 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_178] (rows=525327388 width=375) + Merge Join Operator [MERGEJOIN_183] (rows=525327388 width=375) Conds:RS_54._col0=RS_55._col0(Left Semi),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_55] @@ -279,64 +279,64 @@ Stage-0 Output:["_col0"],keys:_col0 Select Operator [SEL_17] (rows=525327388 width=3) Output:["_col0"] - Merge Join Operator [MERGEJOIN_175] (rows=525327388 width=3) - Conds:RS_207._col0=RS_191._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_180] (rows=525327388 width=3) + Conds:RS_212._col0=RS_196._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_191] + PARTITION_ONLY_SHUFFLE [RS_196] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_207] + SHUFFLE [RS_212] PartitionCols:_col0 - Select Operator [SEL_206] (rows=525327388 width=7) + Select Operator [SEL_211] (rows=525327388 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_205] (rows=525327388 width=7) + Filter Operator [FIL_210] (rows=525327388 width=7) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) TableScan [TS_8] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"] <-Reducer 14 [BROADCAST_EDGE] vectorized - BROADCAST [RS_204] - Group By Operator [GBY_203] (rows=1 width=12) + BROADCAST [RS_209] + Group By Operator [GBY_208] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_200] - Group By Operator [GBY_197] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_205] + Group By Operator [GBY_202] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_192] (rows=201 width=4) + Select Operator [SEL_197] (rows=201 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_54] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_174] (rows=228127 width=375) - Conds:RS_49._col1=RS_188._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Merge Join Operator [MERGEJOIN_179] (rows=228127 width=375) + Conds:RS_49._col1=RS_193._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_188] + SHUFFLE [RS_193] PartitionCols:_col0 - Select Operator [SEL_187] (rows=1861800 width=375) + Select Operator [SEL_192] (rows=1861800 width=375) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] TableScan [TS_6] (rows=1861800 width=375) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status","cd_purchase_estimate","cd_credit_rating","cd_dep_count","cd_dep_employed_count","cd_dep_college_count"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_49] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_173] (rows=224946 width=4) - Conds:RS_183._col2=RS_186._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_178] (rows=224946 width=4) + Conds:RS_188._col2=RS_191._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_183] + SHUFFLE [RS_188] PartitionCols:_col2 - Select Operator [SEL_182] (rows=77201384 width=11) + Select Operator [SEL_187] (rows=77201384 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_181] (rows=77201384 width=11) + Filter Operator [FIL_186] (rows=77201384 width=11) predicate:(c_current_cdemo_sk is not null and c_current_addr_sk is not null) TableScan [TS_0] (rows=80000000 width=11) default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_186] + SHUFFLE [RS_191] PartitionCols:_col0 - Select Operator [SEL_185] (rows=116550 width=102) + Select Operator [SEL_190] (rows=116550 width=102) Output:["_col0"] - Filter Operator [FIL_184] (rows=116550 width=102) + Filter Operator [FIL_189] (rows=116550 width=102) predicate:(ca_county) IN ('Walker County', 'Richland County', 'Gaines County', 'Douglas County', 'Dona Ana County') TableScan [TS_3] (rows=40000000 width=102) default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query11.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query11.q.out index cc47c7e7a1..b4231d82da 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query11.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query11.q.out @@ -189,239 +189,241 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_349] - Limit [LIM_348] (rows=100 width=85) + File Output Operator [FS_350] + Limit [LIM_349] (rows=100 width=85) Number of rows:100 - Select Operator [SEL_347] (rows=19066162 width=85) + Select Operator [SEL_348] (rows=19066162 width=85) Output:["_col0"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_89] Select Operator [SEL_88] (rows=19066162 width=85) Output:["_col0"] - Filter Operator [FIL_87] (rows=19066162 width=537) - predicate:CASE WHEN (_col4 is not null) THEN (CASE WHEN (_col2) THEN (((_col6 / _col1) > (_col9 / _col4))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_283] (rows=38132324 width=537) - Conds:RS_84._col3=RS_346._col0(Inner),Output:["_col1","_col2","_col4","_col6","_col8","_col9"] - <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_346] - PartitionCols:_col0 - Select Operator [SEL_345] (rows=80000000 width=297) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_344] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_75] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_74] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=764) - Conds:RS_70._col1=RS_312._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_312] - PartitionCols:_col0 - Select Operator [SEL_311] (rows=80000000 width=656) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - TableScan [TS_65] (rows=80000000 width=656) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_70] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_279] (rows=525327388 width=115) - Conds:RS_343._col0=RS_290._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_290] - PartitionCols:_col0 - Select Operator [SEL_287] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_284] (rows=652 width=8) - predicate:(d_year = 2002) - TableScan [TS_62] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_343] - PartitionCols:_col0 - Select Operator [SEL_342] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_341] (rows=525327388 width=221) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_68_date_dim_d_date_sk_min) AND DynamicValue(RS_68_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_68_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_59] (rows=575995635 width=221) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] - <-Reducer 22 [BROADCAST_EDGE] vectorized - BROADCAST [RS_340] - Group By Operator [GBY_339] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_302] - Group By Operator [GBY_298] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_291] (rows=652 width=4) + Top N Key Operator [TNK_154] (rows=19066162 width=537) + keys:_col8,top n:100 + Filter Operator [FIL_87] (rows=19066162 width=537) + predicate:CASE WHEN (_col4 is not null) THEN (CASE WHEN (_col2) THEN (((_col6 / _col1) > (_col9 / _col4))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_284] (rows=38132324 width=537) + Conds:RS_84._col3=RS_347._col0(Inner),Output:["_col1","_col2","_col4","_col6","_col8","_col9"] + <-Reducer 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_347] + PartitionCols:_col0 + Select Operator [SEL_346] (rows=80000000 width=297) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_345] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_75] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_74] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_281] (rows=525327388 width=764) + Conds:RS_70._col1=RS_313._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_313] + PartitionCols:_col0 + Select Operator [SEL_312] (rows=80000000 width=656) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + TableScan [TS_65] (rows=80000000 width=656) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_70] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=115) + Conds:RS_344._col0=RS_291._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_291] + PartitionCols:_col0 + Select Operator [SEL_288] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_285] (rows=652 width=8) + predicate:(d_year = 2002) + TableScan [TS_62] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_344] + PartitionCols:_col0 + Select Operator [SEL_343] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_342] (rows=525327388 width=221) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_68_date_dim_d_date_sk_min) AND DynamicValue(RS_68_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_68_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_59] (rows=575995635 width=221) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] + <-Reducer 22 [BROADCAST_EDGE] vectorized + BROADCAST [RS_341] + Group By Operator [GBY_340] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_303] + Group By Operator [GBY_299] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_292] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_288] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_84] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_283] (rows=31888273 width=440) + Conds:RS_81._col3=RS_339._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6"] + <-Reducer 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_339] + PartitionCols:_col0 + Select Operator [SEL_338] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_337] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_56] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_55] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_279] (rows=143930993 width=764) + Conds:RS_51._col1=RS_314._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_314] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_312] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_51] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=115) + Conds:RS_336._col0=RS_293._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_293] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_288] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_336] + PartitionCols:_col0 + Select Operator [SEL_335] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_334] (rows=143930993 width=231) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_49_date_dim_d_date_sk_min) AND DynamicValue(RS_49_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_49_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_40] (rows=144002668 width=231) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] + <-Reducer 23 [BROADCAST_EDGE] vectorized + BROADCAST [RS_333] + Group By Operator [GBY_332] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_304] + Group By Operator [GBY_300] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_294] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_288] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_81] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_282] (rows=26666666 width=328) + Conds:RS_321._col0=RS_331._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_331] + PartitionCols:_col0 + Select Operator [SEL_330] (rows=26666666 width=212) + Output:["_col0","_col1"] + Filter Operator [FIL_329] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_328] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_327] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_36] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_35] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_277] (rows=525327388 width=764) + Conds:RS_31._col1=RS_316._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_316] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_312] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_276] (rows=525327388 width=115) + Conds:RS_326._col0=RS_297._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_297] + PartitionCols:_col0 + Select Operator [SEL_290] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_287] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_84] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_282] (rows=31888273 width=440) - Conds:RS_81._col3=RS_338._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6"] - <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_338] - PartitionCols:_col0 - Select Operator [SEL_337] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_336] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_56] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_55] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=764) - Conds:RS_51._col1=RS_313._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_313] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_311] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_51] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_277] (rows=143930993 width=115) - Conds:RS_335._col0=RS_292._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_292] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_287] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_335] - PartitionCols:_col0 - Select Operator [SEL_334] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_333] (rows=143930993 width=231) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_49_date_dim_d_date_sk_min) AND DynamicValue(RS_49_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_49_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_40] (rows=144002668 width=231) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] - <-Reducer 23 [BROADCAST_EDGE] vectorized - BROADCAST [RS_332] - Group By Operator [GBY_331] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_303] - Group By Operator [GBY_299] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_293] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_287] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_81] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_281] (rows=26666666 width=328) - Conds:RS_320._col0=RS_330._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_330] - PartitionCols:_col0 - Select Operator [SEL_329] (rows=26666666 width=212) - Output:["_col0","_col1"] - Filter Operator [FIL_328] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_327] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_326] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_36] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_35] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_276] (rows=525327388 width=764) - Conds:RS_31._col1=RS_315._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_315] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_311] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_275] (rows=525327388 width=115) - Conds:RS_325._col0=RS_296._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_296] - PartitionCols:_col0 - Select Operator [SEL_289] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_286] (rows=652 width=8) - predicate:(d_year = 2001) - Please refer to the previous TableScan [TS_62] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_325] - PartitionCols:_col0 - Select Operator [SEL_324] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_323] (rows=525327388 width=221) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_date_dim_d_date_sk_min) AND DynamicValue(RS_29_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=575995635 width=221) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] - <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_322] - Group By Operator [GBY_321] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_305] - Group By Operator [GBY_301] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_297] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_289] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_320] - PartitionCols:_col0 - Select Operator [SEL_319] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_318] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_317] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_316] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_16] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_15] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_274] (rows=143930993 width=764) - Conds:RS_11._col1=RS_314._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_314] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_311] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_273] (rows=143930993 width=115) - Conds:RS_310._col0=RS_294._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_294] - PartitionCols:_col0 - Select Operator [SEL_288] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_285] (rows=652 width=8) - predicate:(d_year = 2001) - Please refer to the previous TableScan [TS_62] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_310] - PartitionCols:_col0 - Select Operator [SEL_309] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_308] (rows=143930993 width=231) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_date_dim_d_date_sk_min) AND DynamicValue(RS_9_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=231) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_307] - Group By Operator [GBY_306] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_304] - Group By Operator [GBY_300] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_295] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_288] + Filter Operator [FIL_287] (rows=652 width=8) + predicate:(d_year = 2001) + Please refer to the previous TableScan [TS_62] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_326] + PartitionCols:_col0 + Select Operator [SEL_325] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_324] (rows=525327388 width=221) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_date_dim_d_date_sk_min) AND DynamicValue(RS_29_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=575995635 width=221) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] + <-Reducer 25 [BROADCAST_EDGE] vectorized + BROADCAST [RS_323] + Group By Operator [GBY_322] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_306] + Group By Operator [GBY_302] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_298] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_290] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_321] + PartitionCols:_col0 + Select Operator [SEL_320] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_319] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_318] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_317] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_16] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_15] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_275] (rows=143930993 width=764) + Conds:RS_11._col1=RS_315._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_315] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_312] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_274] (rows=143930993 width=115) + Conds:RS_311._col0=RS_295._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_295] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_286] (rows=652 width=8) + predicate:(d_year = 2001) + Please refer to the previous TableScan [TS_62] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_311] + PartitionCols:_col0 + Select Operator [SEL_310] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_309] (rows=143930993 width=231) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_date_dim_d_date_sk_min) AND DynamicValue(RS_9_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=231) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_308] + Group By Operator [GBY_307] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_305] + Group By Operator [GBY_301] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_296] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_289] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query12.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query12.q.out index 57c16347e5..f894d096b2 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query12.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query12.q.out @@ -86,72 +86,74 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_81] - Limit [LIM_80] (rows=100 width=802) + File Output Operator [FS_83] + Limit [LIM_82] (rows=100 width=802) Number of rows:100 - Select Operator [SEL_79] (rows=138600 width=801) + Select Operator [SEL_81] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_78] - Select Operator [SEL_77] (rows=138600 width=801) + SHUFFLE [RS_80] + Select Operator [SEL_79] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_76] (rows=138600 width=690) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] - Select Operator [SEL_75] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_74] - PartitionCols:_col1 - Group By Operator [GBY_73] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_16] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_58] (rows=43190061 width=689) - Conds:RS_12._col1=RS_72._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_72] - PartitionCols:_col0 - Select Operator [SEL_71] (rows=138600 width=581) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_70] (rows=138600 width=581) - predicate:(i_category) IN ('Jewelry', 'Sports', 'Books') - TableScan [TS_6] (rows=462000 width=581) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_57] (rows=143966864 width=115) - Conds:RS_69._col0=RS_61._col0(Inner),Output:["_col1","_col2"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_61] - PartitionCols:_col0 - Select Operator [SEL_60] (rows=8116 width=4) - Output:["_col0"] - Filter Operator [FIL_59] (rows=8116 width=98) - predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' - TableScan [TS_3] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_67] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_66] - Group By Operator [GBY_65] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_64] - Group By Operator [GBY_63] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_62] (rows=8116 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_60] + Top N Key Operator [TNK_78] (rows=138600 width=690) + keys:_col0, _col1, _col2, _col3, ((_col5 * 100) / sum_window_0),top n:100 + PTF Operator [PTF_77] (rows=138600 width=690) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] + Select Operator [SEL_76] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_75] + PartitionCols:_col1 + Group By Operator [GBY_74] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_16] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_59] (rows=43190061 width=689) + Conds:RS_12._col1=RS_73._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_73] + PartitionCols:_col0 + Select Operator [SEL_72] (rows=138600 width=581) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_71] (rows=138600 width=581) + predicate:(i_category) IN ('Jewelry', 'Sports', 'Books') + TableScan [TS_6] (rows=462000 width=581) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_58] (rows=143966864 width=115) + Conds:RS_70._col0=RS_62._col0(Inner),Output:["_col1","_col2"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_62] + PartitionCols:_col0 + Select Operator [SEL_61] (rows=8116 width=4) + Output:["_col0"] + Filter Operator [FIL_60] (rows=8116 width=98) + predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' + TableScan [TS_3] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_70] + PartitionCols:_col0 + Select Operator [SEL_69] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_68] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_67] + Group By Operator [GBY_66] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_65] + Group By Operator [GBY_64] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_63] (rows=8116 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_61] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out index 228b20a8d7..65d3faa20f 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query14.q.out @@ -1,6 +1,6 @@ -Warning: Shuffle Join MERGEJOIN[1191][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product -Warning: Shuffle Join MERGEJOIN[1198][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product -Warning: Shuffle Join MERGEJOIN[1205][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product +Warning: Shuffle Join MERGEJOIN[1193][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product +Warning: Shuffle Join MERGEJOIN[1200][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[1207][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product PREHOOK: query: explain with cross_items as (select i_item_sk ss_item_sk @@ -296,36 +296,36 @@ Stage-0 limit:100 Stage-1 Reducer 9 vectorized - File Output Operator [FS_1361] - Limit [LIM_1360] (rows=100 width=223) + File Output Operator [FS_1363] + Limit [LIM_1362] (rows=100 width=223) Number of rows:100 - Select Operator [SEL_1359] (rows=304320 width=223) + Select Operator [SEL_1361] (rows=304320 width=223) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1358] - Select Operator [SEL_1357] (rows=304320 width=223) + SHUFFLE [RS_1360] + Select Operator [SEL_1359] (rows=304320 width=223) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_1356] (rows=304320 width=231) + Group By Operator [GBY_1358] (rows=304320 width=231) Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 7 [SIMPLE_EDGE] <-Reducer 16 [CONTAINS] - Reduce Output Operator [RS_1204] + Reduce Output Operator [RS_1206] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_1203] (rows=304320 width=231) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L - Top N Key Operator [TNK_1202] (rows=121728 width=221) - keys:_col0, _col1, _col2, _col3, 0L,top n:100 - Select Operator [SEL_1200] (rows=40576 width=223) + Top N Key Operator [TNK_1205] (rows=304320 width=231) + keys:_col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_1204] (rows=304320 width=231) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L + Select Operator [SEL_1202] (rows=40576 width=223) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_1199] (rows=40576 width=244) + Filter Operator [FIL_1201] (rows=40576 width=244) predicate:(_col3 > _col5) - Merge Join Operator [MERGEJOIN_1198] (rows=121728 width=244) + Merge Join Operator [MERGEJOIN_1200] (rows=121728 width=244) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 15 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1373] - Filter Operator [FIL_1372] (rows=121728 width=132) + PARTITION_ONLY_SHUFFLE [RS_1375] + Filter Operator [FIL_1374] (rows=121728 width=132) predicate:_col3 is not null - Group By Operator [GBY_1371] (rows=121728 width=132) + Group By Operator [GBY_1373] (rows=121728 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_238] @@ -334,374 +334,374 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 Select Operator [SEL_235] (rows=286549727 width=127) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_1171] (rows=286549727 width=127) - Conds:RS_232._col1=RS_1339._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"] + Merge Join Operator [MERGEJOIN_1173] (rows=286549727 width=127) + Conds:RS_232._col1=RS_1341._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1339] + SHUFFLE [RS_1341] PartitionCols:_col0 - Select Operator [SEL_1330] (rows=462000 width=15) + Select Operator [SEL_1332] (rows=462000 width=15) Output:["_col0","_col1","_col2","_col3"] TableScan [TS_81] (rows=462000 width=15) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_232] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1170] (rows=286549727 width=119) + Merge Join Operator [MERGEJOIN_1172] (rows=286549727 width=119) Conds:RS_229._col1=RS_230._col0(Inner),Output:["_col1","_col2","_col3"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_229] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1162] (rows=286549727 width=119) - Conds:RS_1366._col0=RS_1306._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_1164] (rows=286549727 width=119) + Conds:RS_1368._col0=RS_1308._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 10 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1306] + PARTITION_ONLY_SHUFFLE [RS_1308] PartitionCols:_col0 - Select Operator [SEL_1303] (rows=50 width=4) + Select Operator [SEL_1305] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_1302] (rows=50 width=12) + Filter Operator [FIL_1304] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 11)) TableScan [TS_3] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 79 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1366] + SHUFFLE [RS_1368] PartitionCols:_col0 - Select Operator [SEL_1365] (rows=286549727 width=123) + Select Operator [SEL_1367] (rows=286549727 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1364] (rows=286549727 width=123) + Filter Operator [FIL_1366] (rows=286549727 width=123) predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_227_date_dim_d_date_sk_min) AND DynamicValue(RS_227_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_227_date_dim_d_date_sk_bloom_filter))) TableScan [TS_143] (rows=287989836 width=123) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_quantity","cs_list_price"] <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1363] - Group By Operator [GBY_1362] (rows=1 width=12) + BROADCAST [RS_1365] + Group By Operator [GBY_1364] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1314] - Group By Operator [GBY_1311] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1316] + Group By Operator [GBY_1313] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1307] (rows=50 width=4) + Select Operator [SEL_1309] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1303] + Please refer to the previous Select Operator [SEL_1305] <-Reducer 34 [SIMPLE_EDGE] SHUFFLE [RS_230] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_1169] (rows=729 width=4) - Conds:RS_1347._col1, _col2, _col3=RS_1370._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_1171] (rows=729 width=4) + Conds:RS_1349._col1, _col2, _col3=RS_1372._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1347] + SHUFFLE [RS_1349] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_1340] (rows=458612 width=15) + Select Operator [SEL_1342] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1331] (rows=458612 width=15) + Filter Operator [FIL_1333] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null) Please refer to the previous TableScan [TS_81] <-Reducer 33 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1370] + SHUFFLE [RS_1372] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_1369] (rows=1 width=12) + Select Operator [SEL_1371] (rows=1 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1368] (rows=1 width=20) + Filter Operator [FIL_1370] (rows=1 width=20) predicate:(_col3 = 3L) - Group By Operator [GBY_1367] (rows=120960 width=20) + Group By Operator [GBY_1369] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 32 [SIMPLE_EDGE] <-Reducer 31 [CONTAINS] vectorized - Reduce Output Operator [RS_1424] + Reduce Output Operator [RS_1426] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1423] (rows=120960 width=20) + Group By Operator [GBY_1425] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1422] (rows=120960 width=20) + Group By Operator [GBY_1424] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_169] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_25] (rows=3144960 width=19) Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, _col5, _col6 - Merge Join Operator [MERGEJOIN_1151] (rows=546042657 width=11) - Conds:RS_21._col1=RS_1344._col0(Inner),Output:["_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_1153] (rows=546042657 width=11) + Conds:RS_21._col1=RS_1346._col0(Inner),Output:["_col4","_col5","_col6"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1344] + SHUFFLE [RS_1346] PartitionCols:_col0 - Select Operator [SEL_1336] (rows=458612 width=15) + Select Operator [SEL_1338] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1327] (rows=458612 width=15) + Filter Operator [FIL_1329] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null) Please refer to the previous TableScan [TS_81] <-Reducer 25 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1150] (rows=550076554 width=4) - Conds:RS_1418._col0=RS_1396._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_1152] (rows=550076554 width=4) + Conds:RS_1420._col0=RS_1398._col0(Inner),Output:["_col1"] <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1396] + SHUFFLE [RS_1398] PartitionCols:_col0 - Select Operator [SEL_1395] (rows=1957 width=4) + Select Operator [SEL_1397] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_1394] (rows=1957 width=8) + Filter Operator [FIL_1396] (rows=1957 width=8) predicate:d_year BETWEEN 1999 AND 2001 TableScan [TS_12] (rows=73049 width=8) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1418] + SHUFFLE [RS_1420] PartitionCols:_col0 - Select Operator [SEL_1417] (rows=550076554 width=7) + Select Operator [SEL_1419] (rows=550076554 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_1416] (rows=550076554 width=7) + Filter Operator [FIL_1418] (rows=550076554 width=7) predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_19_d1_d_date_sk_min) AND DynamicValue(RS_19_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_19_d1_d_date_sk_bloom_filter))) TableScan [TS_9] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"] <-Reducer 40 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1415] - Group By Operator [GBY_1414] (rows=1 width=12) + BROADCAST [RS_1417] + Group By Operator [GBY_1416] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1410] - Group By Operator [GBY_1406] (rows=1 width=12) + SHUFFLE [RS_1412] + Group By Operator [GBY_1408] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1397] (rows=1957 width=4) + Select Operator [SEL_1399] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Reducer 44 [CONTAINS] vectorized - Reduce Output Operator [RS_1438] + Reduce Output Operator [RS_1440] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1437] (rows=120960 width=20) + Group By Operator [GBY_1439] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1436] (rows=120960 width=20) + Group By Operator [GBY_1438] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 42 [SIMPLE_EDGE] SHUFFLE [RS_189] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_45] (rows=1693440 width=19) Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, _col5, _col6 - Merge Join Operator [MERGEJOIN_1153] (rows=284448361 width=11) - Conds:RS_41._col1=RS_1345._col0(Inner),Output:["_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_1155] (rows=284448361 width=11) + Conds:RS_41._col1=RS_1347._col0(Inner),Output:["_col4","_col5","_col6"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1345] + SHUFFLE [RS_1347] PartitionCols:_col0 - Select Operator [SEL_1337] (rows=458612 width=15) + Select Operator [SEL_1339] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1328] (rows=458612 width=15) + Filter Operator [FIL_1330] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null) Please refer to the previous TableScan [TS_81] <-Reducer 41 [SIMPLE_EDGE] SHUFFLE [RS_41] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1152] (rows=286549727 width=4) - Conds:RS_1432._col0=RS_1398._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_1154] (rows=286549727 width=4) + Conds:RS_1434._col0=RS_1400._col0(Inner),Output:["_col1"] <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1398] + SHUFFLE [RS_1400] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Map 63 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1432] + SHUFFLE [RS_1434] PartitionCols:_col0 - Select Operator [SEL_1431] (rows=286549727 width=7) + Select Operator [SEL_1433] (rows=286549727 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_1430] (rows=286549727 width=7) + Filter Operator [FIL_1432] (rows=286549727 width=7) predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_39_d2_d_date_sk_min) AND DynamicValue(RS_39_d2_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_39_d2_d_date_sk_bloom_filter))) TableScan [TS_29] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk"] <-Reducer 46 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1429] - Group By Operator [GBY_1428] (rows=1 width=12) + BROADCAST [RS_1431] + Group By Operator [GBY_1430] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1411] - Group By Operator [GBY_1407] (rows=1 width=12) + SHUFFLE [RS_1413] + Group By Operator [GBY_1409] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1399] (rows=1957 width=4) + Select Operator [SEL_1401] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Reducer 50 [CONTAINS] vectorized - Reduce Output Operator [RS_1452] + Reduce Output Operator [RS_1454] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1451] (rows=120960 width=20) + Group By Operator [GBY_1453] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1450] (rows=120960 width=20) + Group By Operator [GBY_1452] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 48 [SIMPLE_EDGE] SHUFFLE [RS_210] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_66] (rows=846720 width=19) Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, _col5, _col6 - Merge Join Operator [MERGEJOIN_1155] (rows=142911107 width=11) - Conds:RS_62._col1=RS_1346._col0(Inner),Output:["_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_1157] (rows=142911107 width=11) + Conds:RS_62._col1=RS_1348._col0(Inner),Output:["_col4","_col5","_col6"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1346] + SHUFFLE [RS_1348] PartitionCols:_col0 - Select Operator [SEL_1338] (rows=458612 width=15) + Select Operator [SEL_1340] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1329] (rows=458612 width=15) + Filter Operator [FIL_1331] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null) Please refer to the previous TableScan [TS_81] <-Reducer 47 [SIMPLE_EDGE] SHUFFLE [RS_62] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1154] (rows=143966864 width=4) - Conds:RS_1446._col0=RS_1400._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_1156] (rows=143966864 width=4) + Conds:RS_1448._col0=RS_1402._col0(Inner),Output:["_col1"] <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1400] + SHUFFLE [RS_1402] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Map 64 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1446] + SHUFFLE [RS_1448] PartitionCols:_col0 - Select Operator [SEL_1445] (rows=143966864 width=7) + Select Operator [SEL_1447] (rows=143966864 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_1444] (rows=143966864 width=7) + Filter Operator [FIL_1446] (rows=143966864 width=7) predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_60_d3_d_date_sk_min) AND DynamicValue(RS_60_d3_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_60_d3_d_date_sk_bloom_filter))) TableScan [TS_50] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk"] <-Reducer 52 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1443] - Group By Operator [GBY_1442] (rows=1 width=12) + BROADCAST [RS_1445] + Group By Operator [GBY_1444] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1412] - Group By Operator [GBY_1408] (rows=1 width=12) + SHUFFLE [RS_1414] + Group By Operator [GBY_1410] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1401] (rows=1957 width=4) + Select Operator [SEL_1403] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Reducer 59 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1377] - Select Operator [SEL_1376] (rows=1 width=112) + PARTITION_ONLY_SHUFFLE [RS_1379] + Select Operator [SEL_1378] (rows=1 width=112) Output:["_col0"] - Filter Operator [FIL_1375] (rows=1 width=120) + Filter Operator [FIL_1377] (rows=1 width=120) predicate:(_col0 is not null and _col1 is not null) - Group By Operator [GBY_1374] (rows=1 width=120) + Group By Operator [GBY_1376] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"] <-Union 58 [CUSTOM_SIMPLE_EDGE] <-Reducer 57 [CONTAINS] - Reduce Output Operator [RS_1259] - Group By Operator [GBY_1258] (rows=1 width=120) + Reduce Output Operator [RS_1261] + Group By Operator [GBY_1260] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1257] (rows=980593145 width=112) + Select Operator [SEL_1259] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1255] (rows=550076554 width=110) + Select Operator [SEL_1257] (rows=550076554 width=110) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1254] (rows=550076554 width=110) - Conds:RS_1461._col0=RS_1404._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1256] (rows=550076554 width=110) + Conds:RS_1463._col0=RS_1406._col0(Inner),Output:["_col1","_col2"] <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1404] + SHUFFLE [RS_1406] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Map 66 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1461] + SHUFFLE [RS_1463] PartitionCols:_col0 - Select Operator [SEL_1459] (rows=550076554 width=114) + Select Operator [SEL_1461] (rows=550076554 width=114) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1458] (rows=550076554 width=114) + Filter Operator [FIL_1460] (rows=550076554 width=114) predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_106_date_dim_d_date_sk_min) AND DynamicValue(RS_106_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_106_date_dim_d_date_sk_bloom_filter))) TableScan [TS_99] (rows=575995635 width=114) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_quantity","ss_list_price"] <-Reducer 56 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1457] - Group By Operator [GBY_1456] (rows=1 width=12) + BROADCAST [RS_1459] + Group By Operator [GBY_1458] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 39 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1413] - Group By Operator [GBY_1409] (rows=1 width=12) + SHUFFLE [RS_1415] + Group By Operator [GBY_1411] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1403] (rows=1957 width=4) + Select Operator [SEL_1405] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Reducer 69 [CONTAINS] - Reduce Output Operator [RS_1277] - Group By Operator [GBY_1276] (rows=1 width=120) + Reduce Output Operator [RS_1279] + Group By Operator [GBY_1278] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1275] (rows=980593145 width=112) + Select Operator [SEL_1277] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1273] (rows=286549727 width=115) + Select Operator [SEL_1275] (rows=286549727 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1272] (rows=286549727 width=115) - Conds:RS_1476._col0=RS_1467._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1274] (rows=286549727 width=115) + Conds:RS_1478._col0=RS_1469._col0(Inner),Output:["_col1","_col2"] <-Map 71 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1467] + PARTITION_ONLY_SHUFFLE [RS_1469] PartitionCols:_col0 - Select Operator [SEL_1464] (rows=1957 width=4) + Select Operator [SEL_1466] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_1463] (rows=1957 width=8) + Filter Operator [FIL_1465] (rows=1957 width=8) predicate:d_year BETWEEN 1998 AND 2000 TableScan [TS_112] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 67 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1476] + SHUFFLE [RS_1478] PartitionCols:_col0 - Select Operator [SEL_1474] (rows=286549727 width=119) + Select Operator [SEL_1476] (rows=286549727 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1473] (rows=286549727 width=119) + Filter Operator [FIL_1475] (rows=286549727 width=119) predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_116_date_dim_d_date_sk_min) AND DynamicValue(RS_116_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_116_date_dim_d_date_sk_bloom_filter))) TableScan [TS_109] (rows=287989836 width=119) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_quantity","cs_list_price"] <-Reducer 72 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1472] - Group By Operator [GBY_1471] (rows=1 width=12) + BROADCAST [RS_1474] + Group By Operator [GBY_1473] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 71 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1470] - Group By Operator [GBY_1469] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1472] + Group By Operator [GBY_1471] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1466] (rows=1957 width=4) + Select Operator [SEL_1468] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1464] + Please refer to the previous Select Operator [SEL_1466] <-Reducer 75 [CONTAINS] - Reduce Output Operator [RS_1295] - Group By Operator [GBY_1294] (rows=1 width=120) + Reduce Output Operator [RS_1297] + Group By Operator [GBY_1296] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1293] (rows=980593145 width=112) + Select Operator [SEL_1295] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1291] (rows=143966864 width=115) + Select Operator [SEL_1293] (rows=143966864 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1290] (rows=143966864 width=115) - Conds:RS_1491._col0=RS_1482._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1292] (rows=143966864 width=115) + Conds:RS_1493._col0=RS_1484._col0(Inner),Output:["_col1","_col2"] <-Map 77 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1482] + PARTITION_ONLY_SHUFFLE [RS_1484] PartitionCols:_col0 - Select Operator [SEL_1479] (rows=1957 width=4) + Select Operator [SEL_1481] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_1478] (rows=1957 width=8) + Filter Operator [FIL_1480] (rows=1957 width=8) predicate:d_year BETWEEN 1998 AND 2000 TableScan [TS_123] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 73 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1491] + SHUFFLE [RS_1493] PartitionCols:_col0 - Select Operator [SEL_1489] (rows=143966864 width=119) + Select Operator [SEL_1491] (rows=143966864 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1488] (rows=143966864 width=119) + Filter Operator [FIL_1490] (rows=143966864 width=119) predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_127_date_dim_d_date_sk_min) AND DynamicValue(RS_127_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_127_date_dim_d_date_sk_bloom_filter))) TableScan [TS_120] (rows=144002668 width=119) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_quantity","ws_list_price"] <-Reducer 78 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1487] - Group By Operator [GBY_1486] (rows=1 width=12) + BROADCAST [RS_1489] + Group By Operator [GBY_1488] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 77 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1485] - Group By Operator [GBY_1484] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1487] + Group By Operator [GBY_1486] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1481] (rows=1957 width=4) + Select Operator [SEL_1483] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1479] + Please refer to the previous Select Operator [SEL_1481] <-Reducer 22 [CONTAINS] - Reduce Output Operator [RS_1211] + Reduce Output Operator [RS_1213] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_1210] (rows=304320 width=231) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L - Top N Key Operator [TNK_1209] (rows=121728 width=221) - keys:_col0, _col1, _col2, _col3, 0L,top n:100 - Select Operator [SEL_1207] (rows=40576 width=219) + Top N Key Operator [TNK_1212] (rows=304320 width=231) + keys:_col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_1211] (rows=304320 width=231) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L + Select Operator [SEL_1209] (rows=40576 width=219) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_1206] (rows=40576 width=244) + Filter Operator [FIL_1208] (rows=40576 width=244) predicate:(_col3 > _col5) - Merge Join Operator [MERGEJOIN_1205] (rows=121728 width=244) + Merge Join Operator [MERGEJOIN_1207] (rows=121728 width=244) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1389] - Filter Operator [FIL_1388] (rows=121728 width=132) + PARTITION_ONLY_SHUFFLE [RS_1391] + Filter Operator [FIL_1390] (rows=121728 width=132) predicate:_col3 is not null - Group By Operator [GBY_1387] (rows=121728 width=132) + Group By Operator [GBY_1389] (rows=121728 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_382] @@ -710,185 +710,185 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 Select Operator [SEL_379] (rows=143966864 width=127) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_1184] (rows=143966864 width=127) - Conds:RS_376._col1=RS_1341._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"] + Merge Join Operator [MERGEJOIN_1186] (rows=143966864 width=127) + Conds:RS_376._col1=RS_1343._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1341] + SHUFFLE [RS_1343] PartitionCols:_col0 - Select Operator [SEL_1332] (rows=462000 width=15) + Select Operator [SEL_1334] (rows=462000 width=15) Output:["_col0","_col1","_col2","_col3"] Please refer to the previous TableScan [TS_81] <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_376] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1183] (rows=143966864 width=119) + Merge Join Operator [MERGEJOIN_1185] (rows=143966864 width=119) Conds:RS_373._col1=RS_374._col0(Inner),Output:["_col1","_col2","_col3"] <-Reducer 18 [SIMPLE_EDGE] SHUFFLE [RS_373] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1175] (rows=143966864 width=119) - Conds:RS_1382._col0=RS_1308._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_1177] (rows=143966864 width=119) + Conds:RS_1384._col0=RS_1310._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 10 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1308] + PARTITION_ONLY_SHUFFLE [RS_1310] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1303] + Please refer to the previous Select Operator [SEL_1305] <-Map 80 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1382] + SHUFFLE [RS_1384] PartitionCols:_col0 - Select Operator [SEL_1381] (rows=143966864 width=123) + Select Operator [SEL_1383] (rows=143966864 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1380] (rows=143966864 width=123) + Filter Operator [FIL_1382] (rows=143966864 width=123) predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_371_date_dim_d_date_sk_min) AND DynamicValue(RS_371_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_371_date_dim_d_date_sk_bloom_filter))) TableScan [TS_287] (rows=144002668 width=123) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_quantity","ws_list_price"] <-Reducer 23 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1379] - Group By Operator [GBY_1378] (rows=1 width=12) + BROADCAST [RS_1381] + Group By Operator [GBY_1380] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1315] - Group By Operator [GBY_1312] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1317] + Group By Operator [GBY_1314] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1309] (rows=50 width=4) + Select Operator [SEL_1311] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1303] + Please refer to the previous Select Operator [SEL_1305] <-Reducer 38 [SIMPLE_EDGE] SHUFFLE [RS_374] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_1182] (rows=729 width=4) - Conds:RS_1348._col1, _col2, _col3=RS_1386._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_1184] (rows=729 width=4) + Conds:RS_1350._col1, _col2, _col3=RS_1388._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1348] + SHUFFLE [RS_1350] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_1342] (rows=458612 width=15) + Select Operator [SEL_1344] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1333] (rows=458612 width=15) + Filter Operator [FIL_1335] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null) Please refer to the previous TableScan [TS_81] <-Reducer 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1386] + SHUFFLE [RS_1388] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_1385] (rows=1 width=12) + Select Operator [SEL_1387] (rows=1 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1384] (rows=1 width=20) + Filter Operator [FIL_1386] (rows=1 width=20) predicate:(_col3 = 3L) - Group By Operator [GBY_1383] (rows=120960 width=20) + Group By Operator [GBY_1385] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 36 [SIMPLE_EDGE] <-Reducer 35 [CONTAINS] vectorized - Reduce Output Operator [RS_1427] + Reduce Output Operator [RS_1429] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1426] (rows=120960 width=20) + Group By Operator [GBY_1428] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1425] (rows=120960 width=20) + Group By Operator [GBY_1427] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_313] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_25] <-Reducer 45 [CONTAINS] vectorized - Reduce Output Operator [RS_1441] + Reduce Output Operator [RS_1443] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1440] (rows=120960 width=20) + Group By Operator [GBY_1442] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1439] (rows=120960 width=20) + Group By Operator [GBY_1441] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 42 [SIMPLE_EDGE] SHUFFLE [RS_333] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_45] <-Reducer 51 [CONTAINS] vectorized - Reduce Output Operator [RS_1455] + Reduce Output Operator [RS_1457] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1454] (rows=120960 width=20) + Group By Operator [GBY_1456] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1453] (rows=120960 width=20) + Group By Operator [GBY_1455] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 48 [SIMPLE_EDGE] SHUFFLE [RS_354] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_66] <-Reducer 62 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1393] - Select Operator [SEL_1392] (rows=1 width=112) + PARTITION_ONLY_SHUFFLE [RS_1395] + Select Operator [SEL_1394] (rows=1 width=112) Output:["_col0"] - Filter Operator [FIL_1391] (rows=1 width=120) + Filter Operator [FIL_1393] (rows=1 width=120) predicate:(_col0 is not null and _col1 is not null) - Group By Operator [GBY_1390] (rows=1 width=120) + Group By Operator [GBY_1392] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"] <-Union 61 [CUSTOM_SIMPLE_EDGE] <-Reducer 60 [CONTAINS] - Reduce Output Operator [RS_1265] - Group By Operator [GBY_1264] (rows=1 width=120) + Reduce Output Operator [RS_1267] + Group By Operator [GBY_1266] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1263] (rows=980593145 width=112) + Select Operator [SEL_1265] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1261] (rows=550076554 width=110) + Select Operator [SEL_1263] (rows=550076554 width=110) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1260] (rows=550076554 width=110) - Conds:RS_1462._col0=RS_1405._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1262] (rows=550076554 width=110) + Conds:RS_1464._col0=RS_1407._col0(Inner),Output:["_col1","_col2"] <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1405] + SHUFFLE [RS_1407] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Map 66 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1462] + SHUFFLE [RS_1464] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1459] + Please refer to the previous Select Operator [SEL_1461] <-Reducer 70 [CONTAINS] - Reduce Output Operator [RS_1283] - Group By Operator [GBY_1282] (rows=1 width=120) + Reduce Output Operator [RS_1285] + Group By Operator [GBY_1284] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1281] (rows=980593145 width=112) + Select Operator [SEL_1283] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1279] (rows=286549727 width=115) + Select Operator [SEL_1281] (rows=286549727 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1278] (rows=286549727 width=115) - Conds:RS_1477._col0=RS_1468._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1280] (rows=286549727 width=115) + Conds:RS_1479._col0=RS_1470._col0(Inner),Output:["_col1","_col2"] <-Map 71 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1468] + PARTITION_ONLY_SHUFFLE [RS_1470] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1464] + Please refer to the previous Select Operator [SEL_1466] <-Map 67 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1477] + SHUFFLE [RS_1479] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1474] + Please refer to the previous Select Operator [SEL_1476] <-Reducer 76 [CONTAINS] - Reduce Output Operator [RS_1301] - Group By Operator [GBY_1300] (rows=1 width=120) + Reduce Output Operator [RS_1303] + Group By Operator [GBY_1302] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1299] (rows=980593145 width=112) + Select Operator [SEL_1301] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1297] (rows=143966864 width=115) + Select Operator [SEL_1299] (rows=143966864 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1296] (rows=143966864 width=115) - Conds:RS_1492._col0=RS_1483._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1298] (rows=143966864 width=115) + Conds:RS_1494._col0=RS_1485._col0(Inner),Output:["_col1","_col2"] <-Map 77 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1483] + PARTITION_ONLY_SHUFFLE [RS_1485] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1479] + Please refer to the previous Select Operator [SEL_1481] <-Map 73 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1492] + SHUFFLE [RS_1494] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1489] + Please refer to the previous Select Operator [SEL_1491] <-Reducer 6 [CONTAINS] - Reduce Output Operator [RS_1197] + Reduce Output Operator [RS_1199] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_1196] (rows=304320 width=231) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L - Top N Key Operator [TNK_1195] (rows=121728 width=221) - keys:_col0, _col1, _col2, _col3, 0L,top n:100 - Select Operator [SEL_1193] (rows=40576 width=221) + Top N Key Operator [TNK_1198] (rows=304320 width=231) + keys:_col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_1197] (rows=304320 width=231) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L + Select Operator [SEL_1195] (rows=40576 width=221) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_1192] (rows=40576 width=244) + Filter Operator [FIL_1194] (rows=40576 width=244) predicate:(_col3 > _col5) - Merge Join Operator [MERGEJOIN_1191] (rows=121728 width=244) + Merge Join Operator [MERGEJOIN_1193] (rows=121728 width=244) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1351] - Filter Operator [FIL_1350] (rows=121728 width=132) + PARTITION_ONLY_SHUFFLE [RS_1353] + Filter Operator [FIL_1352] (rows=121728 width=132) predicate:_col3 is not null - Group By Operator [GBY_1349] (rows=121728 width=132) + Group By Operator [GBY_1351] (rows=121728 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_95] @@ -897,165 +897,165 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 Select Operator [SEL_92] (rows=550076554 width=122) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_1158] (rows=550076554 width=122) - Conds:RS_89._col1=RS_1334._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"] + Merge Join Operator [MERGEJOIN_1160] (rows=550076554 width=122) + Conds:RS_89._col1=RS_1336._col0(Inner),Output:["_col2","_col3","_col7","_col8","_col9"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1334] + SHUFFLE [RS_1336] PartitionCols:_col0 - Select Operator [SEL_1325] (rows=462000 width=15) + Select Operator [SEL_1327] (rows=462000 width=15) Output:["_col0","_col1","_col2","_col3"] Please refer to the previous TableScan [TS_81] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_89] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1157] (rows=550076554 width=114) + Merge Join Operator [MERGEJOIN_1159] (rows=550076554 width=114) Conds:RS_86._col1=RS_87._col0(Inner),Output:["_col1","_col2","_col3"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_86] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1149] (rows=550076554 width=114) - Conds:RS_1320._col0=RS_1304._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_1151] (rows=550076554 width=114) + Conds:RS_1322._col0=RS_1306._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 10 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1304] + PARTITION_ONLY_SHUFFLE [RS_1306] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1303] + Please refer to the previous Select Operator [SEL_1305] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1320] + SHUFFLE [RS_1322] PartitionCols:_col0 - Select Operator [SEL_1319] (rows=550076554 width=118) + Select Operator [SEL_1321] (rows=550076554 width=118) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1318] (rows=550076554 width=118) + Filter Operator [FIL_1320] (rows=550076554 width=118) predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_84_date_dim_d_date_sk_min) AND DynamicValue(RS_84_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_84_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=118) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_quantity","ss_list_price"] <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1317] - Group By Operator [GBY_1316] (rows=1 width=12) + BROADCAST [RS_1319] + Group By Operator [GBY_1318] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1313] - Group By Operator [GBY_1310] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1315] + Group By Operator [GBY_1312] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1305] (rows=50 width=4) + Select Operator [SEL_1307] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1303] + Please refer to the previous Select Operator [SEL_1305] <-Reducer 30 [SIMPLE_EDGE] SHUFFLE [RS_87] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_1156] (rows=729 width=4) - Conds:RS_1343._col1, _col2, _col3=RS_1324._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_1158] (rows=729 width=4) + Conds:RS_1345._col1, _col2, _col3=RS_1326._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1343] + SHUFFLE [RS_1345] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_1335] (rows=458612 width=15) + Select Operator [SEL_1337] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1326] (rows=458612 width=15) + Filter Operator [FIL_1328] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null) Please refer to the previous TableScan [TS_81] <-Reducer 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1324] + SHUFFLE [RS_1326] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_1323] (rows=1 width=12) + Select Operator [SEL_1325] (rows=1 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1322] (rows=1 width=20) + Filter Operator [FIL_1324] (rows=1 width=20) predicate:(_col3 = 3L) - Group By Operator [GBY_1321] (rows=120960 width=20) + Group By Operator [GBY_1323] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 28 [SIMPLE_EDGE] <-Reducer 27 [CONTAINS] vectorized - Reduce Output Operator [RS_1421] + Reduce Output Operator [RS_1423] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1420] (rows=120960 width=20) + Group By Operator [GBY_1422] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1419] (rows=120960 width=20) + Group By Operator [GBY_1421] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_25] <-Reducer 43 [CONTAINS] vectorized - Reduce Output Operator [RS_1435] + Reduce Output Operator [RS_1437] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1434] (rows=120960 width=20) + Group By Operator [GBY_1436] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1433] (rows=120960 width=20) + Group By Operator [GBY_1435] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 42 [SIMPLE_EDGE] SHUFFLE [RS_46] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_45] <-Reducer 49 [CONTAINS] vectorized - Reduce Output Operator [RS_1449] + Reduce Output Operator [RS_1451] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1448] (rows=120960 width=20) + Group By Operator [GBY_1450] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1447] (rows=120960 width=20) + Group By Operator [GBY_1449] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 48 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_66] <-Reducer 55 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1355] - Select Operator [SEL_1354] (rows=1 width=112) + PARTITION_ONLY_SHUFFLE [RS_1357] + Select Operator [SEL_1356] (rows=1 width=112) Output:["_col0"] - Filter Operator [FIL_1353] (rows=1 width=120) + Filter Operator [FIL_1355] (rows=1 width=120) predicate:(_col0 is not null and _col1 is not null) - Group By Operator [GBY_1352] (rows=1 width=120) + Group By Operator [GBY_1354] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"] <-Union 54 [CUSTOM_SIMPLE_EDGE] <-Reducer 53 [CONTAINS] - Reduce Output Operator [RS_1253] - Group By Operator [GBY_1252] (rows=1 width=120) + Reduce Output Operator [RS_1255] + Group By Operator [GBY_1254] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1251] (rows=980593145 width=112) + Select Operator [SEL_1253] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1249] (rows=550076554 width=110) + Select Operator [SEL_1251] (rows=550076554 width=110) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1248] (rows=550076554 width=110) - Conds:RS_1460._col0=RS_1402._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1250] (rows=550076554 width=110) + Conds:RS_1462._col0=RS_1404._col0(Inner),Output:["_col1","_col2"] <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1402] + SHUFFLE [RS_1404] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1395] + Please refer to the previous Select Operator [SEL_1397] <-Map 66 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1460] + SHUFFLE [RS_1462] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1459] + Please refer to the previous Select Operator [SEL_1461] <-Reducer 68 [CONTAINS] - Reduce Output Operator [RS_1271] - Group By Operator [GBY_1270] (rows=1 width=120) + Reduce Output Operator [RS_1273] + Group By Operator [GBY_1272] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1269] (rows=980593145 width=112) + Select Operator [SEL_1271] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1267] (rows=286549727 width=115) + Select Operator [SEL_1269] (rows=286549727 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1266] (rows=286549727 width=115) - Conds:RS_1475._col0=RS_1465._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1268] (rows=286549727 width=115) + Conds:RS_1477._col0=RS_1467._col0(Inner),Output:["_col1","_col2"] <-Map 71 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1465] + PARTITION_ONLY_SHUFFLE [RS_1467] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1464] + Please refer to the previous Select Operator [SEL_1466] <-Map 67 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1475] + SHUFFLE [RS_1477] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1474] + Please refer to the previous Select Operator [SEL_1476] <-Reducer 74 [CONTAINS] - Reduce Output Operator [RS_1289] - Group By Operator [GBY_1288] (rows=1 width=120) + Reduce Output Operator [RS_1291] + Group By Operator [GBY_1290] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1287] (rows=980593145 width=112) + Select Operator [SEL_1289] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1285] (rows=143966864 width=115) + Select Operator [SEL_1287] (rows=143966864 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1284] (rows=143966864 width=115) - Conds:RS_1490._col0=RS_1480._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1286] (rows=143966864 width=115) + Conds:RS_1492._col0=RS_1482._col0(Inner),Output:["_col1","_col2"] <-Map 77 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1480] + PARTITION_ONLY_SHUFFLE [RS_1482] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1479] + Please refer to the previous Select Operator [SEL_1481] <-Map 73 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1490] + SHUFFLE [RS_1492] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1489] + Please refer to the previous Select Operator [SEL_1491] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query15.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query15.q.out index 5268ed3ecf..6de127d824 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query15.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query15.q.out @@ -62,81 +62,81 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_97] - Limit [LIM_96] (rows=100 width=201) + File Output Operator [FS_102] + Limit [LIM_101] (rows=100 width=201) Number of rows:100 - Select Operator [SEL_95] (rows=10141 width=201) + Select Operator [SEL_100] (rows=10141 width=201) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_94] - Group By Operator [GBY_93] (rows=10141 width=201) + SHUFFLE [RS_99] + Group By Operator [GBY_98] (rows=10141 width=201) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col0 Group By Operator [GBY_23] (rows=2403417 width=201) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col3 - Top N Key Operator [TNK_43] (rows=285117831 width=212) - keys:_col3,top n:100 - Select Operator [SEL_22] (rows=285117831 width=212) - Output:["_col3","_col8"] + Select Operator [SEL_22] (rows=285117831 width=212) + Output:["_col3","_col8"] + Top N Key Operator [TNK_46] (rows=285117831 width=212) + keys:_col3,top n:100 Filter Operator [FIL_21] (rows=285117831 width=212) predicate:(_col9 or _col4 or _col5) - Merge Join Operator [MERGEJOIN_76] (rows=285117831 width=212) + Merge Join Operator [MERGEJOIN_81] (rows=285117831 width=212) Conds:RS_18._col0=RS_19._col1(Inner),Output:["_col3","_col4","_col5","_col8","_col9"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_74] (rows=80000000 width=101) - Conds:RS_79._col1=RS_81._col0(Inner),Output:["_col0","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_79] (rows=80000000 width=101) + Conds:RS_84._col1=RS_86._col0(Inner),Output:["_col0","_col3","_col4","_col5"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_79] + SHUFFLE [RS_84] PartitionCols:_col1 - Select Operator [SEL_78] (rows=80000000 width=8) + Select Operator [SEL_83] (rows=80000000 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_77] (rows=80000000 width=8) + Filter Operator [FIL_82] (rows=80000000 width=8) predicate:c_current_addr_sk is not null TableScan [TS_0] (rows=80000000 width=8) default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_81] + SHUFFLE [RS_86] PartitionCols:_col0 - Select Operator [SEL_80] (rows=40000000 width=101) + Select Operator [SEL_85] (rows=40000000 width=101) Output:["_col0","_col1","_col2","_col3"] TableScan [TS_3] (rows=40000000 width=179) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_zip"] <-Reducer 8 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_75] (rows=285117831 width=119) - Conds:RS_92._col0=RS_84._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_80] (rows=285117831 width=119) + Conds:RS_97._col0=RS_89._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_84] + SHUFFLE [RS_89] PartitionCols:_col0 - Select Operator [SEL_83] (rows=130 width=4) + Select Operator [SEL_88] (rows=130 width=4) Output:["_col0"] - Filter Operator [FIL_82] (rows=130 width=12) + Filter Operator [FIL_87] (rows=130 width=12) predicate:((d_year = 2000) and (d_qoy = 2)) TableScan [TS_8] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] + SHUFFLE [RS_97] PartitionCols:_col0 - Select Operator [SEL_91] (rows=285117831 width=123) + Select Operator [SEL_96] (rows=285117831 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_90] (rows=285117831 width=119) + Filter Operator [FIL_95] (rows=285117831 width=119) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_12_date_dim_d_date_sk_min) AND DynamicValue(RS_12_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_12_date_dim_d_date_sk_bloom_filter))) TableScan [TS_5] (rows=287989836 width=119) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_sales_price"] <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_89] - Group By Operator [GBY_88] (rows=1 width=12) + BROADCAST [RS_94] + Group By Operator [GBY_93] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_87] - Group By Operator [GBY_86] (rows=1 width=12) + SHUFFLE [RS_92] + Group By Operator [GBY_91] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_85] (rows=130 width=4) + Select Operator [SEL_90] (rows=130 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_83] + Please refer to the previous Select Operator [SEL_88] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query17.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query17.q.out index d96222d9e1..1a795279d1 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query17.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query17.q.out @@ -122,144 +122,144 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_248] - Limit [LIM_247] (rows=100 width=466) + File Output Operator [FS_253] + Limit [LIM_252] (rows=100 width=466) Number of rows:100 - Select Operator [SEL_246] (rows=97302218301 width=466) + Select Operator [SEL_251] (rows=97302218301 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_245] - Select Operator [SEL_244] (rows=97302218301 width=466) + SHUFFLE [RS_250] + Select Operator [SEL_249] (rows=97302218301 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] - Group By Operator [GBY_243] (rows=97302218301 width=466) + Group By Operator [GBY_248] (rows=97302218301 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","count(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","count(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_48] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_47] (rows=97302218301 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["count(_col3)","sum(_col3)","sum(_col7)","sum(_col6)","count(_col4)","sum(_col4)","sum(_col9)","sum(_col8)","count(_col5)","sum(_col5)","sum(_col11)","sum(_col10)"],keys:_col0, _col1, _col2 - Top N Key Operator [TNK_94] (rows=97302218301 width=381) - keys:_col0, _col1, _col2,top n:100 - Select Operator [SEL_45] (rows=97302218301 width=381) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - Merge Join Operator [MERGEJOIN_210] (rows=97302218301 width=381) - Conds:RS_42._col6=RS_242._col0(Inner),Output:["_col3","_col10","_col16","_col19","_col21","_col22"] + Select Operator [SEL_45] (rows=97302218301 width=381) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + Top N Key Operator [TNK_97] (rows=97302218301 width=381) + keys:_col21, _col22, _col19,top n:100 + Merge Join Operator [MERGEJOIN_215] (rows=97302218301 width=381) + Conds:RS_42._col6=RS_247._col0(Inner),Output:["_col3","_col10","_col16","_col19","_col21","_col22"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_242] + SHUFFLE [RS_247] PartitionCols:_col0 - Select Operator [SEL_241] (rows=462000 width=288) + Select Operator [SEL_246] (rows=462000 width=288) Output:["_col0","_col1","_col2"] TableScan [TS_31] (rows=462000 width=288) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_42] PartitionCols:_col6 - Merge Join Operator [MERGEJOIN_209] (rows=97302218301 width=101) - Conds:RS_39._col8=RS_240._col0(Inner),Output:["_col3","_col6","_col10","_col16","_col19"] + Merge Join Operator [MERGEJOIN_214] (rows=97302218301 width=101) + Conds:RS_39._col8=RS_245._col0(Inner),Output:["_col3","_col6","_col10","_col16","_col19"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_240] + SHUFFLE [RS_245] PartitionCols:_col0 - Select Operator [SEL_239] (rows=1704 width=90) + Select Operator [SEL_244] (rows=1704 width=90) Output:["_col0","_col1"] TableScan [TS_29] (rows=1704 width=90) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_39] PartitionCols:_col8 - Merge Join Operator [MERGEJOIN_208] (rows=97302218301 width=19) + Merge Join Operator [MERGEJOIN_213] (rows=97302218301 width=19) Conds:RS_36._col1, _col2=RS_37._col9, _col8(Inner),Output:["_col3","_col6","_col8","_col10","_col16"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_37] PartitionCols:_col9, _col8 - Merge Join Operator [MERGEJOIN_207] (rows=478292911 width=23) + Merge Join Operator [MERGEJOIN_212] (rows=478292911 width=23) Conds:RS_25._col2, _col1, _col4=RS_26._col2, _col1, _col3(Inner),Output:["_col1","_col3","_col5","_col8","_col9","_col11"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col2, _col1, _col4 - Merge Join Operator [MERGEJOIN_205] (rows=501694138 width=19) - Conds:RS_235._col0=RS_219._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_210] (rows=501694138 width=19) + Conds:RS_240._col0=RS_224._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_219] + PARTITION_ONLY_SHUFFLE [RS_224] PartitionCols:_col0 - Select Operator [SEL_215] (rows=101 width=4) + Select Operator [SEL_220] (rows=101 width=4) Output:["_col0"] - Filter Operator [FIL_212] (rows=101 width=94) + Filter Operator [FIL_217] (rows=101 width=94) predicate:(d_quarter_name = '2000Q1') TableScan [TS_3] (rows=73049 width=94) default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_quarter_name"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_235] + SHUFFLE [RS_240] PartitionCols:_col0 - Select Operator [SEL_234] (rows=501694138 width=23) + Select Operator [SEL_239] (rows=501694138 width=23) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_233] (rows=501694138 width=23) + Filter Operator [FIL_238] (rows=501694138 width=23) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_23_d1_d_date_sk_min) AND DynamicValue(RS_23_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_23_d1_d_date_sk_bloom_filter))) TableScan [TS_6] (rows=575995635 width=23) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_quantity"] <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_232] - Group By Operator [GBY_231] (rows=1 width=12) + BROADCAST [RS_237] + Group By Operator [GBY_236] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_225] - Group By Operator [GBY_223] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_230] + Group By Operator [GBY_228] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_220] (rows=101 width=4) + Select Operator [SEL_225] (rows=101 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_215] + Please refer to the previous Select Operator [SEL_220] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col2, _col1, _col3 - Merge Join Operator [MERGEJOIN_206] (rows=53632139 width=15) - Conds:RS_238._col0=RS_221._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_211] (rows=53632139 width=15) + Conds:RS_243._col0=RS_226._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_221] + PARTITION_ONLY_SHUFFLE [RS_226] PartitionCols:_col0 - Select Operator [SEL_216] (rows=304 width=4) + Select Operator [SEL_221] (rows=304 width=4) Output:["_col0"] - Filter Operator [FIL_213] (rows=304 width=94) + Filter Operator [FIL_218] (rows=304 width=94) predicate:(d_quarter_name) IN ('2000Q1', '2000Q2', '2000Q3') Please refer to the previous TableScan [TS_3] <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_238] + SHUFFLE [RS_243] PartitionCols:_col0 - Select Operator [SEL_237] (rows=53632139 width=19) + Select Operator [SEL_242] (rows=53632139 width=19) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_236] (rows=53632139 width=19) + Filter Operator [FIL_241] (rows=53632139 width=19) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null) TableScan [TS_12] (rows=57591150 width=19) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number","sr_return_quantity"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_36] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_204] (rows=285117831 width=11) - Conds:RS_230._col0=RS_217._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_209] (rows=285117831 width=11) + Conds:RS_235._col0=RS_222._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_217] + PARTITION_ONLY_SHUFFLE [RS_222] PartitionCols:_col0 - Select Operator [SEL_214] (rows=304 width=4) + Select Operator [SEL_219] (rows=304 width=4) Output:["_col0"] - Filter Operator [FIL_211] (rows=304 width=94) + Filter Operator [FIL_216] (rows=304 width=94) predicate:(d_quarter_name) IN ('2000Q1', '2000Q2', '2000Q3') Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_230] + SHUFFLE [RS_235] PartitionCols:_col0 - Select Operator [SEL_229] (rows=285117831 width=15) + Select Operator [SEL_234] (rows=285117831 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_228] (rows=285117831 width=15) + Filter Operator [FIL_233] (rows=285117831 width=15) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_34_d3_d_date_sk_min) AND DynamicValue(RS_34_d3_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_34_d3_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=15) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_quantity"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_227] - Group By Operator [GBY_226] (rows=1 width=12) + BROADCAST [RS_232] + Group By Operator [GBY_231] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_224] - Group By Operator [GBY_222] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_229] + Group By Operator [GBY_227] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_218] (rows=304 width=4) + Select Operator [SEL_223] (rows=304 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_214] + Please refer to the previous Select Operator [SEL_219] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query18.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query18.q.out index c3c17a2efc..e9199407f0 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query18.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query18.q.out @@ -97,117 +97,119 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_174] - Limit [LIM_173] (rows=100 width=1165) + File Output Operator [FS_176] + Limit [LIM_175] (rows=100 width=1165) Number of rows:100 - Select Operator [SEL_172] (rows=82276185 width=1165) + Select Operator [SEL_174] (rows=82276185 width=1165) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_171] - Select Operator [SEL_170] (rows=82276185 width=1165) + SHUFFLE [RS_173] + Select Operator [SEL_172] (rows=82276185 width=1165) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - Group By Operator [GBY_169] (rows=82276185 width=1229) - Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)","sum(VALUE._col8)","count(VALUE._col9)","sum(VALUE._col10)","count(VALUE._col11)","sum(VALUE._col12)","count(VALUE._col13)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_39] (rows=82276185 width=1229) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(_col12)","count(_col12)","sum(_col13)","count(_col13)","sum(_col14)","count(_col14)","sum(_col15)","count(_col15)","sum(_col16)","count(_col16)","sum(_col3)","count(_col3)","sum(_col19)","count(_col19)"],keys:_col21, _col5, _col6, _col7, 0L - Merge Join Operator [MERGEJOIN_144] (rows=16455237 width=1117) - Conds:RS_35._col1=RS_168._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col12","_col13","_col14","_col15","_col16","_col19","_col21"] - <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_168] - PartitionCols:_col0 - Select Operator [SEL_167] (rows=1861800 width=4) - Output:["_col0"] - TableScan [TS_24] (rows=1861800 width=4) - default@customer_demographics,cd2,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_143] (rows=16225785 width=1120) - Conds:RS_32._col11=RS_166._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col12","_col13","_col14","_col15","_col16","_col19","_col21"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_166] - PartitionCols:_col0 - Select Operator [SEL_165] (rows=462000 width=104) - Output:["_col0","_col1"] - TableScan [TS_22] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col11 - Merge Join Operator [MERGEJOIN_142] (rows=16225785 width=1024) - Conds:RS_29._col0=RS_30._col1(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col11","_col12","_col13","_col14","_col15","_col16","_col19"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_141] (rows=16225785 width=640) - Conds:RS_18._col2=RS_164._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_164] - PartitionCols:_col0 - Select Operator [SEL_163] (rows=103434 width=116) - Output:["_col0","_col1"] - Filter Operator [FIL_162] (rows=103434 width=187) - predicate:((cd_education_status = 'College') and (cd_gender = 'M')) - TableScan [TS_12] (rows=1861800 width=187) - default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_education_status","cd_dep_count"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_140] (rows=283692098 width=569) - Conds:RS_161._col0=RS_153._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_153] - PartitionCols:_col0 - Select Operator [SEL_152] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_151] (rows=652 width=8) - predicate:(d_year = 2001) - TableScan [TS_9] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_161] - PartitionCols:_col0 - Select Operator [SEL_160] (rows=283692098 width=573) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_159] (rows=283692098 width=466) - predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_6] (rows=287989836 width=466) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_bill_cdemo_sk","cs_item_sk","cs_quantity","cs_list_price","cs_sales_price","cs_coupon_amt","cs_net_profit"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_158] - Group By Operator [GBY_157] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_156] - Group By Operator [GBY_155] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_154] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_152] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_139] (rows=4890586 width=371) - Conds:RS_147._col2=RS_150._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6","_col7"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_147] - PartitionCols:_col2 - Select Operator [SEL_146] (rows=35631408 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_145] (rows=35631408 width=19) - predicate:((c_birth_month) IN (9, 5, 12, 4, 1, 10) and c_current_cdemo_sk is not null and c_current_addr_sk is not null) - TableScan [TS_0] (rows=80000000 width=19) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk","c_birth_month","c_birth_year"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_150] - PartitionCols:_col0 - Select Operator [SEL_149] (rows=5490196 width=285) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_148] (rows=5490196 width=285) - predicate:(ca_state) IN ('ND', 'WI', 'AL', 'NC', 'OK', 'MS', 'TN') - TableScan [TS_3] (rows=40000000 width=285) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state","ca_country"] + Top N Key Operator [TNK_171] (rows=82276185 width=1229) + keys:_col3, _col2, _col1, _col0,top n:100 + Group By Operator [GBY_170] (rows=82276185 width=1229) + Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)","sum(VALUE._col8)","count(VALUE._col9)","sum(VALUE._col10)","count(VALUE._col11)","sum(VALUE._col12)","count(VALUE._col13)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_39] (rows=82276185 width=1229) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(_col12)","count(_col12)","sum(_col13)","count(_col13)","sum(_col14)","count(_col14)","sum(_col15)","count(_col15)","sum(_col16)","count(_col16)","sum(_col3)","count(_col3)","sum(_col19)","count(_col19)"],keys:_col21, _col5, _col6, _col7, 0L + Merge Join Operator [MERGEJOIN_145] (rows=16455237 width=1117) + Conds:RS_35._col1=RS_169._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col12","_col13","_col14","_col15","_col16","_col19","_col21"] + <-Map 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_169] + PartitionCols:_col0 + Select Operator [SEL_168] (rows=1861800 width=4) + Output:["_col0"] + TableScan [TS_24] (rows=1861800 width=4) + default@customer_demographics,cd2,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_144] (rows=16225785 width=1120) + Conds:RS_32._col11=RS_167._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col12","_col13","_col14","_col15","_col16","_col19","_col21"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_167] + PartitionCols:_col0 + Select Operator [SEL_166] (rows=462000 width=104) + Output:["_col0","_col1"] + TableScan [TS_22] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col11 + Merge Join Operator [MERGEJOIN_143] (rows=16225785 width=1024) + Conds:RS_29._col0=RS_30._col1(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col11","_col12","_col13","_col14","_col15","_col16","_col19"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_142] (rows=16225785 width=640) + Conds:RS_18._col2=RS_165._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_165] + PartitionCols:_col0 + Select Operator [SEL_164] (rows=103434 width=116) + Output:["_col0","_col1"] + Filter Operator [FIL_163] (rows=103434 width=187) + predicate:((cd_education_status = 'College') and (cd_gender = 'M')) + TableScan [TS_12] (rows=1861800 width=187) + default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_education_status","cd_dep_count"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_141] (rows=283692098 width=569) + Conds:RS_162._col0=RS_154._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + <-Map 12 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_154] + PartitionCols:_col0 + Select Operator [SEL_153] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_152] (rows=652 width=8) + predicate:(d_year = 2001) + TableScan [TS_9] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_162] + PartitionCols:_col0 + Select Operator [SEL_161] (rows=283692098 width=573) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_160] (rows=283692098 width=466) + predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_6] (rows=287989836 width=466) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_bill_cdemo_sk","cs_item_sk","cs_quantity","cs_list_price","cs_sales_price","cs_coupon_amt","cs_net_profit"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_159] + Group By Operator [GBY_158] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_157] + Group By Operator [GBY_156] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_155] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_153] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_140] (rows=4890586 width=371) + Conds:RS_148._col2=RS_151._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6","_col7"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_148] + PartitionCols:_col2 + Select Operator [SEL_147] (rows=35631408 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_146] (rows=35631408 width=19) + predicate:((c_birth_month) IN (9, 5, 12, 4, 1, 10) and c_current_cdemo_sk is not null and c_current_addr_sk is not null) + TableScan [TS_0] (rows=80000000 width=19) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk","c_birth_month","c_birth_year"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_151] + PartitionCols:_col0 + Select Operator [SEL_150] (rows=5490196 width=285) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_149] (rows=5490196 width=285) + predicate:(ca_state) IN ('ND', 'WI', 'AL', 'NC', 'OK', 'MS', 'TN') + TableScan [TS_3] (rows=40000000 width=285) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state","ca_country"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query19.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query19.q.out index fff6c4951d..94bf30c04d 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query19.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query19.q.out @@ -78,107 +78,109 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_148] - Limit [LIM_147] (rows=100 width=419) + File Output Operator [FS_150] + Limit [LIM_149] (rows=100 width=419) Number of rows:100 - Select Operator [SEL_146] (rows=76645658 width=418) + Select Operator [SEL_148] (rows=76645658 width=418) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_145] - Select Operator [SEL_144] (rows=76645658 width=418) + SHUFFLE [RS_147] + Select Operator [SEL_146] (rows=76645658 width=418) Output:["_col2","_col3","_col4","_col5","_col6"] - Group By Operator [GBY_143] (rows=76645658 width=314) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_34] (rows=76645658 width=314) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)"],keys:_col12, _col11, _col13, _col14 - Select Operator [SEL_33] (rows=76645658 width=650) - Output:["_col8","_col11","_col12","_col13","_col14"] - Filter Operator [FIL_32] (rows=76645658 width=650) - predicate:(_col3 <> _col16) - Merge Join Operator [MERGEJOIN_121] (rows=76645658 width=650) - Conds:RS_29._col7=RS_142._col0(Inner),Output:["_col3","_col8","_col11","_col12","_col13","_col14","_col16"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_142] - PartitionCols:_col0 - Select Operator [SEL_141] (rows=1704 width=188) - Output:["_col0","_col1"] - TableScan [TS_21] (rows=1704 width=93) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_zip"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col7 - Merge Join Operator [MERGEJOIN_120] (rows=76645658 width=468) - Conds:RS_26._col0=RS_27._col2(Inner),Output:["_col3","_col7","_col8","_col11","_col12","_col13","_col14"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_119] (rows=76645658 width=287) - Conds:RS_17._col1=RS_140._col0(Inner),Output:["_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_140] - PartitionCols:_col0 - Select Operator [SEL_139] (rows=7333 width=206) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_138] (rows=7333 width=210) - predicate:(i_manager_id = 7) - TableScan [TS_11] (rows=462000 width=210) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id","i_manufact","i_manager_id"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_118] (rows=501694138 width=118) - Conds:RS_137._col0=RS_129._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_129] - PartitionCols:_col0 - Select Operator [SEL_128] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_127] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 11)) - TableScan [TS_8] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_137] - PartitionCols:_col0 - Select Operator [SEL_136] (rows=501694138 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_135] (rows=501694138 width=122) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_5] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ext_sales_price"] - <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_134] - Group By Operator [GBY_133] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_132] - Group By Operator [GBY_131] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_130] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_128] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_26] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_117] (rows=80000000 width=188) - Conds:RS_124._col1=RS_126._col0(Inner),Output:["_col0","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_124] - PartitionCols:_col1 - Select Operator [SEL_123] (rows=80000000 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_122] (rows=80000000 width=8) - predicate:c_current_addr_sk is not null - TableScan [TS_0] (rows=80000000 width=8) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_126] - PartitionCols:_col0 - Select Operator [SEL_125] (rows=40000000 width=188) - Output:["_col0","_col1"] - TableScan [TS_3] (rows=40000000 width=93) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_zip"] + Top N Key Operator [TNK_145] (rows=76645658 width=314) + keys:_col4, _col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_144] (rows=76645658 width=314) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_34] (rows=76645658 width=314) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)"],keys:_col12, _col11, _col13, _col14 + Select Operator [SEL_33] (rows=76645658 width=650) + Output:["_col8","_col11","_col12","_col13","_col14"] + Filter Operator [FIL_32] (rows=76645658 width=650) + predicate:(_col3 <> _col16) + Merge Join Operator [MERGEJOIN_122] (rows=76645658 width=650) + Conds:RS_29._col7=RS_143._col0(Inner),Output:["_col3","_col8","_col11","_col12","_col13","_col14","_col16"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_143] + PartitionCols:_col0 + Select Operator [SEL_142] (rows=1704 width=188) + Output:["_col0","_col1"] + TableScan [TS_21] (rows=1704 width=93) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_zip"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col7 + Merge Join Operator [MERGEJOIN_121] (rows=76645658 width=468) + Conds:RS_26._col0=RS_27._col2(Inner),Output:["_col3","_col7","_col8","_col11","_col12","_col13","_col14"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_120] (rows=76645658 width=287) + Conds:RS_17._col1=RS_141._col0(Inner),Output:["_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_141] + PartitionCols:_col0 + Select Operator [SEL_140] (rows=7333 width=206) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_139] (rows=7333 width=210) + predicate:(i_manager_id = 7) + TableScan [TS_11] (rows=462000 width=210) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id","i_manufact","i_manager_id"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_119] (rows=501694138 width=118) + Conds:RS_138._col0=RS_130._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_130] + PartitionCols:_col0 + Select Operator [SEL_129] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_128] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 11)) + TableScan [TS_8] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_138] + PartitionCols:_col0 + Select Operator [SEL_137] (rows=501694138 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_136] (rows=501694138 width=122) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_5] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ext_sales_price"] + <-Reducer 12 [BROADCAST_EDGE] vectorized + BROADCAST [RS_135] + Group By Operator [GBY_134] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_133] + Group By Operator [GBY_132] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_131] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_129] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_26] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_118] (rows=80000000 width=188) + Conds:RS_125._col1=RS_127._col0(Inner),Output:["_col0","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_125] + PartitionCols:_col1 + Select Operator [SEL_124] (rows=80000000 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_123] (rows=80000000 width=8) + predicate:c_current_addr_sk is not null + TableScan [TS_0] (rows=80000000 width=8) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_127] + PartitionCols:_col0 + Select Operator [SEL_126] (rows=40000000 width=188) + Output:["_col0","_col1"] + TableScan [TS_3] (rows=40000000 width=93) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_zip"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query1b.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query1b.q.out index a6276715b4..295efa1f0a 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query1b.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query1b.q.out @@ -323,16 +323,22 @@ STAGE PLANS: 1 _col0 (type: int) outputColumnNames: _col7 Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col7 (type: string) - outputColumnNames: _col0 + Top N Key Operator + sort order: + + keys: _col7 (type: string) + null sort order: z Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + top n: 100 + Select Operator + expressions: _col7 (type: string) + outputColumnNames: _col0 Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 6 Execution mode: vectorized Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out index b71831c7c6..dc3b77f8c8 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query20.q.out @@ -78,72 +78,74 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_81] - Limit [LIM_80] (rows=100 width=802) + File Output Operator [FS_83] + Limit [LIM_82] (rows=100 width=802) Number of rows:100 - Select Operator [SEL_79] (rows=138600 width=801) + Select Operator [SEL_81] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_78] - Select Operator [SEL_77] (rows=138600 width=801) + SHUFFLE [RS_80] + Select Operator [SEL_79] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_76] (rows=138600 width=690) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] - Select Operator [SEL_75] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_74] - PartitionCols:_col1 - Group By Operator [GBY_73] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_16] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_58] (rows=85964922 width=688) - Conds:RS_12._col1=RS_72._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_72] - PartitionCols:_col0 - Select Operator [SEL_71] (rows=138600 width=581) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_70] (rows=138600 width=581) - predicate:(i_category) IN ('Jewelry', 'Sports', 'Books') - TableScan [TS_6] (rows=462000 width=581) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_57] (rows=286549727 width=115) - Conds:RS_69._col0=RS_61._col0(Inner),Output:["_col1","_col2"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_61] - PartitionCols:_col0 - Select Operator [SEL_60] (rows=8116 width=4) - Output:["_col0"] - Filter Operator [FIL_59] (rows=8116 width=98) - predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' - TableScan [TS_3] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=286549727 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_67] (rows=286549727 width=119) - predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=287989836 width=119) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_66] - Group By Operator [GBY_65] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_64] - Group By Operator [GBY_63] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_62] (rows=8116 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_60] + Top N Key Operator [TNK_78] (rows=138600 width=690) + keys:_col0, _col1, _col2, _col3, ((_col5 * 100) / sum_window_0),top n:100 + PTF Operator [PTF_77] (rows=138600 width=690) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] + Select Operator [SEL_76] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_75] + PartitionCols:_col1 + Group By Operator [GBY_74] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_16] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_59] (rows=85964922 width=688) + Conds:RS_12._col1=RS_73._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_73] + PartitionCols:_col0 + Select Operator [SEL_72] (rows=138600 width=581) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_71] (rows=138600 width=581) + predicate:(i_category) IN ('Jewelry', 'Sports', 'Books') + TableScan [TS_6] (rows=462000 width=581) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_58] (rows=286549727 width=115) + Conds:RS_70._col0=RS_62._col0(Inner),Output:["_col1","_col2"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_62] + PartitionCols:_col0 + Select Operator [SEL_61] (rows=8116 width=4) + Output:["_col0"] + Filter Operator [FIL_60] (rows=8116 width=98) + predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' + TableScan [TS_3] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_70] + PartitionCols:_col0 + Select Operator [SEL_69] (rows=286549727 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_68] (rows=286549727 width=119) + predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=287989836 width=119) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_67] + Group By Operator [GBY_66] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_65] + Group By Operator [GBY_64] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_63] (rows=8116 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_61] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query21.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query21.q.out index af2e33e785..a3d6c942fa 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query21.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query21.q.out @@ -80,66 +80,68 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_91] - Limit [LIM_90] (rows=100 width=216) + File Output Operator [FS_93] + Limit [LIM_92] (rows=100 width=216) Number of rows:100 - Select Operator [SEL_89] (rows=115991 width=216) + Select Operator [SEL_91] (rows=115991 width=216) Output:["_col0","_col1","_col2","_col3"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_88] - Filter Operator [FIL_87] (rows=115991 width=216) - predicate:(CASE WHEN ((_col2 > 0L)) THEN ((0.666667D <= (UDFToDouble(_col3) / UDFToDouble(_col2)))) ELSE (false) END and CASE WHEN ((_col2 > 0L)) THEN (((UDFToDouble(_col3) / UDFToDouble(_col2)) <= 1.5D)) ELSE (false) END) - Group By Operator [GBY_86] (rows=463966 width=216) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col0, _col1 - Group By Operator [GBY_21] (rows=463966 width=216) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1 - Select Operator [SEL_19] (rows=463966 width=208) - Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_75] (rows=463966 width=208) - Conds:RS_16._col2=RS_85._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_85] - PartitionCols:_col0 - Select Operator [SEL_84] (rows=27 width=104) - Output:["_col0","_col1"] - TableScan [TS_8] (rows=27 width=104) - default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_16] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_74] (rows=463966 width=112) - Conds:RS_13._col1=RS_83._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_83] - PartitionCols:_col0 - Select Operator [SEL_82] (rows=51333 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_81] (rows=51333 width=215) - predicate:i_current_price BETWEEN 0.99 AND 1.49 - TableScan [TS_5] (rows=462000 width=215) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_current_price"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_13] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_73] (rows=4175715 width=18) - Conds:RS_77._col0=RS_80._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_77] - PartitionCols:_col0 - Select Operator [SEL_76] (rows=37584000 width=15) - Output:["_col0","_col1","_col2","_col3"] - TableScan [TS_0] (rows=37584000 width=15) - default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_80] - PartitionCols:_col0 - Select Operator [SEL_79] (rows=8116 width=12) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_78] (rows=8116 width=98) - predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-03-09 00:00:00' AND TIMESTAMP'1998-05-08 00:00:00' - TableScan [TS_2] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + SHUFFLE [RS_90] + Top N Key Operator [TNK_89] (rows=115991 width=216) + keys:_col0, _col1,top n:100 + Filter Operator [FIL_88] (rows=115991 width=216) + predicate:(CASE WHEN ((_col2 > 0L)) THEN ((0.666667D <= (UDFToDouble(_col3) / UDFToDouble(_col2)))) ELSE (false) END and CASE WHEN ((_col2 > 0L)) THEN (((UDFToDouble(_col3) / UDFToDouble(_col2)) <= 1.5D)) ELSE (false) END) + Group By Operator [GBY_87] (rows=463966 width=216) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col0, _col1 + Group By Operator [GBY_21] (rows=463966 width=216) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1 + Select Operator [SEL_19] (rows=463966 width=208) + Output:["_col0","_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_76] (rows=463966 width=208) + Conds:RS_16._col2=RS_86._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_86] + PartitionCols:_col0 + Select Operator [SEL_85] (rows=27 width=104) + Output:["_col0","_col1"] + TableScan [TS_8] (rows=27 width=104) + default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_16] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_75] (rows=463966 width=112) + Conds:RS_13._col1=RS_84._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_84] + PartitionCols:_col0 + Select Operator [SEL_83] (rows=51333 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_82] (rows=51333 width=215) + predicate:i_current_price BETWEEN 0.99 AND 1.49 + TableScan [TS_5] (rows=462000 width=215) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_current_price"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_13] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_74] (rows=4175715 width=18) + Conds:RS_78._col0=RS_81._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_78] + PartitionCols:_col0 + Select Operator [SEL_77] (rows=37584000 width=15) + Output:["_col0","_col1","_col2","_col3"] + TableScan [TS_0] (rows=37584000 width=15) + default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_81] + PartitionCols:_col0 + Select Operator [SEL_80] (rows=8116 width=12) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_79] (rows=8116 width=98) + predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-03-09 00:00:00' AND TIMESTAMP'1998-05-08 00:00:00' + TableScan [TS_2] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query22.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query22.q.out index cd3c0cc431..9ade7a15f5 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query22.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query22.q.out @@ -63,50 +63,52 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_64] - Limit [LIM_63] (rows=100 width=397) + File Output Operator [FS_66] + Limit [LIM_65] (rows=100 width=397) Number of rows:100 - Select Operator [SEL_62] (rows=32730675 width=397) + Select Operator [SEL_64] (rows=32730675 width=397) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_61] - Select Operator [SEL_60] (rows=32730675 width=397) + SHUFFLE [RS_63] + Select Operator [SEL_62] (rows=32730675 width=397) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_59] (rows=32730675 width=413) - Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_14] (rows=32730675 width=413) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col2)","count(_col2)"],keys:_col5, _col6, _col7, _col8, 0L - Merge Join Operator [MERGEJOIN_51] (rows=6546135 width=391) - Conds:RS_10._col1=RS_58._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_58] - PartitionCols:_col0 - Select Operator [SEL_57] (rows=462000 width=393) - Output:["_col0","_col1","_col2","_col3","_col4"] - TableScan [TS_5] (rows=462000 width=393) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_10] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_50] (rows=6546135 width=6) - Conds:RS_53._col0=RS_56._col0(Inner),Output:["_col1","_col2"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_53] - PartitionCols:_col0 - Select Operator [SEL_52] (rows=37584000 width=11) - Output:["_col0","_col1","_col2"] - TableScan [TS_0] (rows=37584000 width=11) - default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_quantity_on_hand"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_56] - PartitionCols:_col0 - Select Operator [SEL_55] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_54] (rows=317 width=8) - predicate:d_month_seq BETWEEN 1212 AND 1223 - TableScan [TS_2] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + Top N Key Operator [TNK_61] (rows=32730675 width=413) + keys:(UDFToDouble(_col5) / _col6), _col3, _col0, _col1, _col2,top n:100 + Group By Operator [GBY_60] (rows=32730675 width=413) + Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_14] (rows=32730675 width=413) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col2)","count(_col2)"],keys:_col5, _col6, _col7, _col8, 0L + Merge Join Operator [MERGEJOIN_52] (rows=6546135 width=391) + Conds:RS_10._col1=RS_59._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_59] + PartitionCols:_col0 + Select Operator [SEL_58] (rows=462000 width=393) + Output:["_col0","_col1","_col2","_col3","_col4"] + TableScan [TS_5] (rows=462000 width=393) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_10] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_51] (rows=6546135 width=6) + Conds:RS_54._col0=RS_57._col0(Inner),Output:["_col1","_col2"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_54] + PartitionCols:_col0 + Select Operator [SEL_53] (rows=37584000 width=11) + Output:["_col0","_col1","_col2"] + TableScan [TS_0] (rows=37584000 width=11) + default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_quantity_on_hand"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_57] + PartitionCols:_col0 + Select Operator [SEL_56] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_55] (rows=317 width=8) + predicate:d_month_seq BETWEEN 1212 AND 1223 + TableScan [TS_2] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query25.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query25.q.out index adabb76e04..144c5d2cdd 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query25.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query25.q.out @@ -128,140 +128,140 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_246] - Limit [LIM_245] (rows=100 width=808) + File Output Operator [FS_251] + Limit [LIM_250] (rows=100 width=808) Number of rows:100 - Select Operator [SEL_244] (rows=97302218301 width=808) + Select Operator [SEL_249] (rows=97302218301 width=808) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_243] - Group By Operator [GBY_242] (rows=97302218301 width=808) + SHUFFLE [RS_248] + Group By Operator [GBY_247] (rows=97302218301 width=808) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_47] PartitionCols:_col0, _col1, _col2, _col3 Group By Operator [GBY_46] (rows=97302218301 width=808) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col10)","sum(_col16)","sum(_col3)"],keys:_col22, _col23, _col19, _col20 - Top N Key Operator [TNK_93] (rows=97302218301 width=807) + Top N Key Operator [TNK_96] (rows=97302218301 width=807) keys:_col22, _col23, _col19, _col20,top n:100 - Merge Join Operator [MERGEJOIN_209] (rows=97302218301 width=807) - Conds:RS_42._col6=RS_241._col0(Inner),Output:["_col3","_col10","_col16","_col19","_col20","_col22","_col23"] + Merge Join Operator [MERGEJOIN_214] (rows=97302218301 width=807) + Conds:RS_42._col6=RS_246._col0(Inner),Output:["_col3","_col10","_col16","_col19","_col20","_col22","_col23"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_241] + SHUFFLE [RS_246] PartitionCols:_col0 - Select Operator [SEL_240] (rows=462000 width=288) + Select Operator [SEL_245] (rows=462000 width=288) Output:["_col0","_col1","_col2"] TableScan [TS_31] (rows=462000 width=288) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_42] PartitionCols:_col6 - Merge Join Operator [MERGEJOIN_208] (rows=97302218301 width=527) - Conds:RS_39._col8=RS_239._col0(Inner),Output:["_col3","_col6","_col10","_col16","_col19","_col20"] + Merge Join Operator [MERGEJOIN_213] (rows=97302218301 width=527) + Conds:RS_39._col8=RS_244._col0(Inner),Output:["_col3","_col6","_col10","_col16","_col19","_col20"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] + SHUFFLE [RS_244] PartitionCols:_col0 - Select Operator [SEL_238] (rows=1704 width=192) + Select Operator [SEL_243] (rows=1704 width=192) Output:["_col0","_col1","_col2"] TableScan [TS_29] (rows=1704 width=192) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_39] PartitionCols:_col8 - Merge Join Operator [MERGEJOIN_207] (rows=97302218301 width=343) + Merge Join Operator [MERGEJOIN_212] (rows=97302218301 width=343) Conds:RS_36._col1, _col2=RS_37._col9, _col8(Inner),Output:["_col3","_col6","_col8","_col10","_col16"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_37] PartitionCols:_col9, _col8 - Merge Join Operator [MERGEJOIN_206] (rows=478292911 width=234) + Merge Join Operator [MERGEJOIN_211] (rows=478292911 width=234) Conds:RS_25._col2, _col1, _col4=RS_26._col2, _col1, _col3(Inner),Output:["_col1","_col3","_col5","_col8","_col9","_col11"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col2, _col1, _col4 - Merge Join Operator [MERGEJOIN_204] (rows=501694138 width=122) - Conds:RS_234._col0=RS_218._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_209] (rows=501694138 width=122) + Conds:RS_239._col0=RS_223._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_218] + PARTITION_ONLY_SHUFFLE [RS_223] PartitionCols:_col0 - Select Operator [SEL_214] (rows=50 width=4) + Select Operator [SEL_219] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_211] (rows=50 width=12) + Filter Operator [FIL_216] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 4)) TableScan [TS_3] (rows=73049 width=12) default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_234] + SHUFFLE [RS_239] PartitionCols:_col0 - Select Operator [SEL_233] (rows=501694138 width=126) + Select Operator [SEL_238] (rows=501694138 width=126) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_232] (rows=501694138 width=126) + Filter Operator [FIL_237] (rows=501694138 width=126) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_23_d1_d_date_sk_min) AND DynamicValue(RS_23_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_23_d1_d_date_sk_bloom_filter))) TableScan [TS_6] (rows=575995635 width=126) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_net_profit"] <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_231] - Group By Operator [GBY_230] (rows=1 width=12) + BROADCAST [RS_236] + Group By Operator [GBY_235] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_224] - Group By Operator [GBY_222] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_229] + Group By Operator [GBY_227] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_219] (rows=50 width=4) + Select Operator [SEL_224] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_214] + Please refer to the previous Select Operator [SEL_219] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col2, _col1, _col3 - Merge Join Operator [MERGEJOIN_205] (rows=53632139 width=119) - Conds:RS_237._col0=RS_220._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_210] (rows=53632139 width=119) + Conds:RS_242._col0=RS_225._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_220] + PARTITION_ONLY_SHUFFLE [RS_225] PartitionCols:_col0 - Select Operator [SEL_215] (rows=351 width=4) + Select Operator [SEL_220] (rows=351 width=4) Output:["_col0"] - Filter Operator [FIL_212] (rows=351 width=12) + Filter Operator [FIL_217] (rows=351 width=12) predicate:((d_year = 2000) and d_moy BETWEEN 4 AND 10) Please refer to the previous TableScan [TS_3] <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_237] + SHUFFLE [RS_242] PartitionCols:_col0 - Select Operator [SEL_236] (rows=53632139 width=123) + Select Operator [SEL_241] (rows=53632139 width=123) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_235] (rows=53632139 width=123) + Filter Operator [FIL_240] (rows=53632139 width=123) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null) TableScan [TS_12] (rows=57591150 width=123) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number","sr_net_loss"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_36] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_203] (rows=285117831 width=119) - Conds:RS_229._col0=RS_216._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_208] (rows=285117831 width=119) + Conds:RS_234._col0=RS_221._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_216] + PARTITION_ONLY_SHUFFLE [RS_221] PartitionCols:_col0 - Select Operator [SEL_213] (rows=351 width=4) + Select Operator [SEL_218] (rows=351 width=4) Output:["_col0"] - Filter Operator [FIL_210] (rows=351 width=12) + Filter Operator [FIL_215] (rows=351 width=12) predicate:((d_year = 2000) and d_moy BETWEEN 4 AND 10) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_229] + SHUFFLE [RS_234] PartitionCols:_col0 - Select Operator [SEL_228] (rows=285117831 width=123) + Select Operator [SEL_233] (rows=285117831 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_227] (rows=285117831 width=123) + Filter Operator [FIL_232] (rows=285117831 width=123) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_34_d3_d_date_sk_min) AND DynamicValue(RS_34_d3_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_34_d3_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=123) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_net_profit"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_226] - Group By Operator [GBY_225] (rows=1 width=12) + BROADCAST [RS_231] + Group By Operator [GBY_230] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_223] - Group By Operator [GBY_221] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_228] + Group By Operator [GBY_226] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_217] (rows=351 width=4) + Select Operator [SEL_222] (rows=351 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_213] + Please refer to the previous Select Operator [SEL_218] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query26.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query26.q.out index 824bbe6769..44f7ce328f 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query26.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query26.q.out @@ -67,93 +67,93 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_123] - Limit [LIM_122] (rows=100 width=444) + File Output Operator [FS_128] + Limit [LIM_127] (rows=100 width=444) Number of rows:100 - Select Operator [SEL_121] (rows=310774 width=444) + Select Operator [SEL_126] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_120] - Select Operator [SEL_119] (rows=310774 width=444) + SHUFFLE [RS_125] + Select Operator [SEL_124] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_118] (rows=310774 width=476) + Group By Operator [GBY_123] (rows=310774 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)"],keys:KEY._col0 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col0 Group By Operator [GBY_27] (rows=462000 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col4)","count(_col4)","sum(_col5)","count(_col5)","sum(_col7)","count(_col7)","sum(_col6)","count(_col6)"],keys:_col12 - Top N Key Operator [TNK_54] (rows=2317924 width=231) + Top N Key Operator [TNK_57] (rows=2317924 width=231) keys:_col12,top n:100 - Merge Join Operator [MERGEJOIN_98] (rows=2317924 width=231) - Conds:RS_23._col2=RS_117._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] + Merge Join Operator [MERGEJOIN_103] (rows=2317924 width=231) + Conds:RS_23._col2=RS_122._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] + SHUFFLE [RS_122] PartitionCols:_col0 - Select Operator [SEL_116] (rows=462000 width=104) + Select Operator [SEL_121] (rows=462000 width=104) Output:["_col0","_col1"] TableScan [TS_12] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_97] (rows=2317924 width=135) - Conds:RS_20._col3=RS_115._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_102] (rows=2317924 width=135) + Conds:RS_20._col3=RS_120._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_115] + SHUFFLE [RS_120] PartitionCols:_col0 - Select Operator [SEL_114] (rows=2300 width=4) + Select Operator [SEL_119] (rows=2300 width=4) Output:["_col0"] - Filter Operator [FIL_113] (rows=2300 width=174) + Filter Operator [FIL_118] (rows=2300 width=174) predicate:((p_channel_email = 'N') or (p_channel_event = 'N')) TableScan [TS_9] (rows=2300 width=174) default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_email","p_channel_event"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_96] (rows=2317924 width=137) - Conds:RS_17._col0=RS_112._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_101] (rows=2317924 width=137) + Conds:RS_17._col0=RS_117._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6","_col7"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_112] + SHUFFLE [RS_117] PartitionCols:_col0 - Select Operator [SEL_111] (rows=652 width=4) + Select Operator [SEL_116] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_110] (rows=652 width=8) + Filter Operator [FIL_115] (rows=652 width=8) predicate:(d_year = 1998) TableScan [TS_6] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_95] (rows=2317924 width=139) - Conds:RS_109._col1=RS_101._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_100] (rows=2317924 width=139) + Conds:RS_114._col1=RS_106._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_101] + PARTITION_ONLY_SHUFFLE [RS_106] PartitionCols:_col0 - Select Operator [SEL_100] (rows=14776 width=4) + Select Operator [SEL_105] (rows=14776 width=4) Output:["_col0"] - Filter Operator [FIL_99] (rows=14776 width=268) + Filter Operator [FIL_104] (rows=14776 width=268) predicate:((cd_marital_status = 'W') and (cd_education_status = 'Primary') and (cd_gender = 'F')) TableScan [TS_3] (rows=1861800 width=268) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_109] + SHUFFLE [RS_114] PartitionCols:_col1 - Select Operator [SEL_108] (rows=283691050 width=354) + Select Operator [SEL_113] (rows=283691050 width=354) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_107] (rows=283691050 width=354) + Filter Operator [FIL_112] (rows=283691050 width=354) predicate:(cs_promo_sk is not null and cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_bill_cdemo_sk BETWEEN DynamicValue(RS_15_customer_demographics_cd_demo_sk_min) AND DynamicValue(RS_15_customer_demographics_cd_demo_sk_max) and in_bloom_filter(cs_bill_cdemo_sk, DynamicValue(RS_15_customer_demographics_cd_demo_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=354) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_cdemo_sk","cs_item_sk","cs_promo_sk","cs_quantity","cs_list_price","cs_sales_price","cs_coupon_amt"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_106] - Group By Operator [GBY_105] (rows=1 width=12) + BROADCAST [RS_111] + Group By Operator [GBY_110] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_104] - Group By Operator [GBY_103] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_109] + Group By Operator [GBY_108] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_102] (rows=14776 width=4) + Select Operator [SEL_107] (rows=14776 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_100] + Please refer to the previous Select Operator [SEL_105] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query27.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query27.q.out index abbd02d6c9..e1a48eaeea 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query27.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query27.q.out @@ -71,95 +71,95 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_124] - Limit [LIM_123] (rows=100 width=538) + File Output Operator [FS_126] + Limit [LIM_125] (rows=100 width=538) Number of rows:100 - Select Operator [SEL_122] (rows=6526254 width=538) + Select Operator [SEL_124] (rows=6526254 width=538) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_121] - Select Operator [SEL_120] (rows=6526254 width=538) + SHUFFLE [RS_123] + Select Operator [SEL_122] (rows=6526254 width=538) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Group By Operator [GBY_119] (rows=6526254 width=570) + Group By Operator [GBY_121] (rows=6526254 width=570) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_28] (rows=13907934 width=570) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(_col2)","count(_col2)","sum(_col3)","count(_col3)","sum(_col4)","count(_col4)","sum(_col5)","count(_col5)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_55] (rows=4635978 width=186) - keys:_col0, _col1, 0L,top n:100 + Top N Key Operator [TNK_57] (rows=13907934 width=570) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_28] (rows=13907934 width=570) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(_col2)","count(_col2)","sum(_col3)","count(_col3)","sum(_col4)","count(_col4)","sum(_col5)","count(_col5)"],keys:_col0, _col1, 0L Select Operator [SEL_26] (rows=4635978 width=186) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_99] (rows=4635978 width=186) - Conds:RS_23._col1=RS_118._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col11","_col13"] + Merge Join Operator [MERGEJOIN_101] (rows=4635978 width=186) + Conds:RS_23._col1=RS_120._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col11","_col13"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_118] + SHUFFLE [RS_120] PartitionCols:_col0 - Select Operator [SEL_117] (rows=462000 width=104) + Select Operator [SEL_119] (rows=462000 width=104) Output:["_col0","_col1"] TableScan [TS_12] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_98] (rows=4635978 width=90) - Conds:RS_20._col3=RS_116._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col11"] + Merge Join Operator [MERGEJOIN_100] (rows=4635978 width=90) + Conds:RS_20._col3=RS_118._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col11"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_116] + SHUFFLE [RS_118] PartitionCols:_col0 - Select Operator [SEL_115] (rows=209 width=90) + Select Operator [SEL_117] (rows=209 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_114] (rows=209 width=90) + Filter Operator [FIL_116] (rows=209 width=90) predicate:(s_state) IN ('SD', 'FL', 'MI', 'LA', 'MO', 'SC') TableScan [TS_9] (rows=1704 width=90) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_97] (rows=4635978 width=4) - Conds:RS_17._col0=RS_113._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_99] (rows=4635978 width=4) + Conds:RS_17._col0=RS_115._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_113] + SHUFFLE [RS_115] PartitionCols:_col0 - Select Operator [SEL_112] (rows=652 width=4) + Select Operator [SEL_114] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_111] (rows=652 width=8) + Filter Operator [FIL_113] (rows=652 width=8) predicate:(d_year = 2001) TableScan [TS_6] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_96] (rows=4635978 width=4) - Conds:RS_110._col2=RS_102._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_98] (rows=4635978 width=4) + Conds:RS_112._col2=RS_104._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_102] + PARTITION_ONLY_SHUFFLE [RS_104] PartitionCols:_col0 - Select Operator [SEL_101] (rows=14776 width=4) + Select Operator [SEL_103] (rows=14776 width=4) Output:["_col0"] - Filter Operator [FIL_100] (rows=14776 width=268) + Filter Operator [FIL_102] (rows=14776 width=268) predicate:((cd_marital_status = 'U') and (cd_education_status = '2 yr Degree') and (cd_gender = 'M')) TableScan [TS_3] (rows=1861800 width=268) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_110] + SHUFFLE [RS_112] PartitionCols:_col2 - Select Operator [SEL_109] (rows=501690006 width=340) + Select Operator [SEL_111] (rows=501690006 width=340) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_108] (rows=501690006 width=340) + Filter Operator [FIL_110] (rows=501690006 width=340) predicate:(ss_cdemo_sk is not null and ss_sold_date_sk is not null and ss_store_sk is not null and ss_cdemo_sk BETWEEN DynamicValue(RS_15_customer_demographics_cd_demo_sk_min) AND DynamicValue(RS_15_customer_demographics_cd_demo_sk_max) and in_bloom_filter(ss_cdemo_sk, DynamicValue(RS_15_customer_demographics_cd_demo_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=340) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_cdemo_sk","ss_store_sk","ss_quantity","ss_list_price","ss_sales_price","ss_coupon_amt"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_107] - Group By Operator [GBY_106] (rows=1 width=12) + BROADCAST [RS_109] + Group By Operator [GBY_108] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_105] - Group By Operator [GBY_104] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_107] + Group By Operator [GBY_106] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_103] (rows=14776 width=4) + Select Operator [SEL_105] (rows=14776 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_101] + Please refer to the previous Select Operator [SEL_103] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query29.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query29.q.out index c308771dfb..2895200eb1 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query29.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query29.q.out @@ -126,141 +126,141 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_246] - Limit [LIM_245] (rows=100 width=496) + File Output Operator [FS_251] + Limit [LIM_250] (rows=100 width=496) Number of rows:100 - Select Operator [SEL_244] (rows=97302218301 width=496) + Select Operator [SEL_249] (rows=97302218301 width=496) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_243] - Group By Operator [GBY_242] (rows=97302218301 width=496) + SHUFFLE [RS_248] + Group By Operator [GBY_247] (rows=97302218301 width=496) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_47] PartitionCols:_col0, _col1, _col2, _col3 Group By Operator [GBY_46] (rows=97302218301 width=496) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col10)","sum(_col16)","sum(_col3)"],keys:_col22, _col23, _col19, _col20 - Top N Key Operator [TNK_93] (rows=97302218301 width=483) + Top N Key Operator [TNK_96] (rows=97302218301 width=483) keys:_col22, _col23, _col19, _col20,top n:100 - Merge Join Operator [MERGEJOIN_209] (rows=97302218301 width=483) - Conds:RS_42._col6=RS_241._col0(Inner),Output:["_col3","_col10","_col16","_col19","_col20","_col22","_col23"] + Merge Join Operator [MERGEJOIN_214] (rows=97302218301 width=483) + Conds:RS_42._col6=RS_246._col0(Inner),Output:["_col3","_col10","_col16","_col19","_col20","_col22","_col23"] <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_241] + SHUFFLE [RS_246] PartitionCols:_col0 - Select Operator [SEL_240] (rows=462000 width=288) + Select Operator [SEL_245] (rows=462000 width=288) Output:["_col0","_col1","_col2"] TableScan [TS_31] (rows=462000 width=288) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_42] PartitionCols:_col6 - Merge Join Operator [MERGEJOIN_208] (rows=97302218301 width=203) - Conds:RS_39._col8=RS_239._col0(Inner),Output:["_col3","_col6","_col10","_col16","_col19","_col20"] + Merge Join Operator [MERGEJOIN_213] (rows=97302218301 width=203) + Conds:RS_39._col8=RS_244._col0(Inner),Output:["_col3","_col6","_col10","_col16","_col19","_col20"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] + SHUFFLE [RS_244] PartitionCols:_col0 - Select Operator [SEL_238] (rows=1704 width=192) + Select Operator [SEL_243] (rows=1704 width=192) Output:["_col0","_col1","_col2"] TableScan [TS_29] (rows=1704 width=192) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_39] PartitionCols:_col8 - Merge Join Operator [MERGEJOIN_207] (rows=97302218301 width=19) + Merge Join Operator [MERGEJOIN_212] (rows=97302218301 width=19) Conds:RS_36._col1, _col2=RS_37._col9, _col8(Inner),Output:["_col3","_col6","_col8","_col10","_col16"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_37] PartitionCols:_col9, _col8 - Merge Join Operator [MERGEJOIN_206] (rows=478292911 width=23) + Merge Join Operator [MERGEJOIN_211] (rows=478292911 width=23) Conds:RS_25._col2, _col1, _col4=RS_26._col2, _col1, _col3(Inner),Output:["_col1","_col3","_col5","_col8","_col9","_col11"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col2, _col1, _col4 - Merge Join Operator [MERGEJOIN_204] (rows=501694138 width=19) - Conds:RS_234._col0=RS_225._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_209] (rows=501694138 width=19) + Conds:RS_239._col0=RS_230._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] + SHUFFLE [RS_230] PartitionCols:_col0 - Select Operator [SEL_223] (rows=50 width=4) + Select Operator [SEL_228] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_221] (rows=50 width=12) + Filter Operator [FIL_226] (rows=50 width=12) predicate:((d_year = 1999) and (d_moy = 4)) TableScan [TS_9] (rows=73049 width=12) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_234] + SHUFFLE [RS_239] PartitionCols:_col0 - Select Operator [SEL_233] (rows=501694138 width=23) + Select Operator [SEL_238] (rows=501694138 width=23) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_232] (rows=501694138 width=23) + Filter Operator [FIL_237] (rows=501694138 width=23) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_23_d1_d_date_sk_min) AND DynamicValue(RS_23_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_23_d1_d_date_sk_bloom_filter))) TableScan [TS_6] (rows=575995635 width=23) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_quantity"] <-Reducer 14 [BROADCAST_EDGE] vectorized - BROADCAST [RS_231] - Group By Operator [GBY_230] (rows=1 width=12) + BROADCAST [RS_236] + Group By Operator [GBY_235] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_229] - Group By Operator [GBY_228] (rows=1 width=12) + SHUFFLE [RS_234] + Group By Operator [GBY_233] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_226] (rows=50 width=4) + Select Operator [SEL_231] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_223] + Please refer to the previous Select Operator [SEL_228] <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col2, _col1, _col3 - Merge Join Operator [MERGEJOIN_205] (rows=53632139 width=15) - Conds:RS_237._col0=RS_227._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_210] (rows=53632139 width=15) + Conds:RS_242._col0=RS_232._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_227] + SHUFFLE [RS_232] PartitionCols:_col0 - Select Operator [SEL_224] (rows=201 width=4) + Select Operator [SEL_229] (rows=201 width=4) Output:["_col0"] - Filter Operator [FIL_222] (rows=201 width=12) + Filter Operator [FIL_227] (rows=201 width=12) predicate:((d_year = 1999) and d_moy BETWEEN 4 AND 7) Please refer to the previous TableScan [TS_9] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_237] + SHUFFLE [RS_242] PartitionCols:_col0 - Select Operator [SEL_236] (rows=53632139 width=19) + Select Operator [SEL_241] (rows=53632139 width=19) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_235] (rows=53632139 width=19) + Filter Operator [FIL_240] (rows=53632139 width=19) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null) TableScan [TS_12] (rows=57591150 width=19) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number","sr_return_quantity"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_36] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_203] (rows=285117831 width=11) - Conds:RS_220._col0=RS_212._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_208] (rows=285117831 width=11) + Conds:RS_225._col0=RS_217._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_212] + PARTITION_ONLY_SHUFFLE [RS_217] PartitionCols:_col0 - Select Operator [SEL_211] (rows=1957 width=4) + Select Operator [SEL_216] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_210] (rows=1957 width=8) + Filter Operator [FIL_215] (rows=1957 width=8) predicate:(d_year) IN (1999, 2000, 2001) TableScan [TS_3] (rows=73049 width=8) default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_220] + SHUFFLE [RS_225] PartitionCols:_col0 - Select Operator [SEL_219] (rows=285117831 width=15) + Select Operator [SEL_224] (rows=285117831 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_218] (rows=285117831 width=15) + Filter Operator [FIL_223] (rows=285117831 width=15) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_34_d3_d_date_sk_min) AND DynamicValue(RS_34_d3_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_34_d3_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=15) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_quantity"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_217] - Group By Operator [GBY_216] (rows=1 width=12) + BROADCAST [RS_222] + Group By Operator [GBY_221] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_215] - Group By Operator [GBY_214] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_220] + Group By Operator [GBY_219] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_213] (rows=1957 width=4) + Select Operator [SEL_218] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_211] + Please refer to the previous Select Operator [SEL_216] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query3.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query3.q.out index 4c1f168168..6057413552 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query3.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query3.q.out @@ -61,63 +61,67 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_72] - Limit [LIM_71] (rows=100 width=220) + File Output Operator [FS_76] + Limit [LIM_75] (rows=100 width=220) Number of rows:100 - Select Operator [SEL_70] (rows=7666836 width=219) + Select Operator [SEL_74] (rows=7666836 width=219) Output:["_col0","_col1","_col2","_col3"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - Group By Operator [GBY_68] (rows=7666836 width=219) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_16] (rows=7666836 width=219) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col7, _col4, _col5 - Merge Join Operator [MERGEJOIN_53] (rows=7666836 width=108) - Conds:RS_12._col0=RS_67._col0(Inner),Output:["_col2","_col4","_col5","_col7"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_67] - PartitionCols:_col0 - Select Operator [SEL_66] (rows=5619 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_65] (rows=5619 width=12) - predicate:(d_moy = 12) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_52] (rows=7666836 width=104) - Conds:RS_64._col1=RS_56._col0(Inner),Output:["_col0","_col2","_col4","_col5"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_56] + SHUFFLE [RS_73] + Top N Key Operator [TNK_72] (rows=7666836 width=219) + keys:_col0, _col3, _col1,top n:100 + Group By Operator [GBY_71] (rows=7666836 width=219) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + Top N Key Operator [TNK_70] (rows=7666836 width=219) + keys:KEY._col0,top n:100 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_16] (rows=7666836 width=219) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col7, _col4, _col5 + Merge Join Operator [MERGEJOIN_55] (rows=7666836 width=108) + Conds:RS_12._col0=RS_69._col0(Inner),Output:["_col2","_col4","_col5","_col7"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] PartitionCols:_col0 - Select Operator [SEL_55] (rows=669 width=107) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_54] (rows=669 width=111) - predicate:(i_manufact_id = 436) - TableScan [TS_3] (rows=462000 width=111) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_64] - PartitionCols:_col1 - Select Operator [SEL_63] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_62] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_61] - Group By Operator [GBY_60] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_59] - Group By Operator [GBY_58] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_57] (rows=669 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_55] + Select Operator [SEL_68] (rows=5619 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_67] (rows=5619 width=12) + predicate:(d_moy = 12) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_54] (rows=7666836 width=104) + Conds:RS_66._col1=RS_58._col0(Inner),Output:["_col0","_col2","_col4","_col5"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=669 width=107) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_56] (rows=669 width=111) + predicate:(i_manufact_id = 436) + TableScan [TS_3] (rows=462000 width=111) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col1 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=669 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query30.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query30.q.out index ea1622883b..cd52a25229 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query30.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query30.q.out @@ -87,139 +87,141 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_215] - Limit [LIM_214] (rows=100 width=949) + File Output Operator [FS_216] + Limit [LIM_215] (rows=100 width=945) Number of rows:100 - Select Operator [SEL_213] (rows=4179738 width=949) + Select Operator [SEL_214] (rows=4179738 width=944) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_66] - Select Operator [SEL_65] (rows=4179738 width=949) + Select Operator [SEL_65] (rows=4179738 width=944) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - Merge Join Operator [MERGEJOIN_180] (rows=4179738 width=949) - Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col17"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_62] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_174] (rows=1568628 width=834) - Conds:RS_183._col2=RS_190._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_190] - PartitionCols:_col0 - Select Operator [SEL_187] (rows=784314 width=4) - Output:["_col0"] - Filter Operator [FIL_184] (rows=784314 width=90) - predicate:(ca_state = 'IL') - TableScan [TS_3] (rows=40000000 width=90) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_183] - PartitionCols:_col2 - Select Operator [SEL_182] (rows=80000000 width=849) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] - Filter Operator [FIL_181] (rows=80000000 width=849) - predicate:c_current_addr_sk is not null - TableScan [TS_0] (rows=80000000 width=849) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_day","c_birth_month","c_birth_year","c_birth_country","c_login","c_email_address","c_last_review_date"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Select Operator [SEL_58] (rows=4179738 width=227) - Output:["_col0","_col2"] - Filter Operator [FIL_57] (rows=4179738 width=227) - predicate:(_col2 > _col3) - Merge Join Operator [MERGEJOIN_179] (rows=12539214 width=227) - Conds:RS_206._col1=RS_212._col1(Inner),Output:["_col0","_col2","_col3"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_212] - PartitionCols:_col1 - Select Operator [SEL_211] (rows=17 width=198) - Output:["_col0","_col1"] - Filter Operator [FIL_210] (rows=17 width=206) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_209] (rows=17 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 - Select Operator [SEL_208] (rows=13130761 width=201) - Output:["_col0","_col2"] - Group By Operator [GBY_207] (rows=13130761 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col0 - Group By Operator [GBY_44] (rows=13130761 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_178] (rows=13130761 width=196) - Conds:RS_40._col2=RS_192._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_192] - PartitionCols:_col0 - Select Operator [SEL_189] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_186] (rows=40000000 width=90) - predicate:ca_state is not null - Please refer to the previous TableScan [TS_3] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_177] (rows=13130761 width=114) - Conds:RS_198._col0=RS_202._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] - PartitionCols:_col0 - Select Operator [SEL_196] (rows=13130761 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_194] (rows=13130761 width=118) - predicate:(wr_returned_date_sk is not null and wr_returning_addr_sk is not null) - TableScan [TS_6] (rows=14398467 width=118) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_returning_customer_sk","wr_returning_addr_sk","wr_return_amt"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_202] - PartitionCols:_col0 - Select Operator [SEL_200] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_199] (rows=652 width=8) - predicate:(d_year = 2002) - TableScan [TS_9] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_206] - PartitionCols:_col1 - Filter Operator [FIL_205] (rows=12539214 width=201) - predicate:_col2 is not null - Select Operator [SEL_204] (rows=12539214 width=201) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_203] (rows=12539214 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=12539214 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_176] (rows=12539214 width=196) - Conds:RS_18._col2=RS_191._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] + Top N Key Operator [TNK_104] (rows=4179738 width=949) + keys:_col1, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col17,top n:100 + Merge Join Operator [MERGEJOIN_181] (rows=4179738 width=949) + Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col17"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_62] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_175] (rows=1568628 width=834) + Conds:RS_184._col2=RS_191._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_191] + PartitionCols:_col0 + Select Operator [SEL_188] (rows=784314 width=4) + Output:["_col0"] + Filter Operator [FIL_185] (rows=784314 width=90) + predicate:(ca_state = 'IL') + TableScan [TS_3] (rows=40000000 width=90) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_184] + PartitionCols:_col2 + Select Operator [SEL_183] (rows=80000000 width=849) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Filter Operator [FIL_182] (rows=80000000 width=849) + predicate:c_current_addr_sk is not null + TableScan [TS_0] (rows=80000000 width=849) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_day","c_birth_month","c_birth_year","c_birth_country","c_login","c_email_address","c_last_review_date"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_58] (rows=4179738 width=227) + Output:["_col0","_col2"] + Filter Operator [FIL_57] (rows=4179738 width=227) + predicate:(_col2 > _col3) + Merge Join Operator [MERGEJOIN_180] (rows=12539214 width=227) + Conds:RS_207._col1=RS_213._col1(Inner),Output:["_col0","_col2","_col3"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_213] + PartitionCols:_col1 + Select Operator [SEL_212] (rows=17 width=198) + Output:["_col0","_col1"] + Filter Operator [FIL_211] (rows=17 width=206) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_210] (rows=17 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 + Select Operator [SEL_209] (rows=13130761 width=201) + Output:["_col0","_col2"] + Group By Operator [GBY_208] (rows=13130761 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_45] PartitionCols:_col0 - Select Operator [SEL_188] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_185] (rows=40000000 width=90) - predicate:ca_state is not null - Please refer to the previous TableScan [TS_3] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_175] (rows=12539214 width=114) - Conds:RS_197._col0=RS_201._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_197] - PartitionCols:_col0 - Select Operator [SEL_195] (rows=12539214 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_193] (rows=12539214 width=118) - predicate:(wr_returning_customer_sk is not null and wr_returned_date_sk is not null and wr_returning_addr_sk is not null) - Please refer to the previous TableScan [TS_6] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_200] + Group By Operator [GBY_44] (rows=13130761 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_179] (rows=13130761 width=196) + Conds:RS_40._col2=RS_193._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_193] + PartitionCols:_col0 + Select Operator [SEL_190] (rows=40000000 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_187] (rows=40000000 width=90) + predicate:ca_state is not null + Please refer to the previous TableScan [TS_3] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_178] (rows=13130761 width=114) + Conds:RS_199._col0=RS_203._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_199] + PartitionCols:_col0 + Select Operator [SEL_197] (rows=13130761 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_195] (rows=13130761 width=118) + predicate:(wr_returned_date_sk is not null and wr_returning_addr_sk is not null) + TableScan [TS_6] (rows=14398467 width=118) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_returning_customer_sk","wr_returning_addr_sk","wr_return_amt"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_203] + PartitionCols:_col0 + Select Operator [SEL_201] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_200] (rows=652 width=8) + predicate:(d_year = 2002) + TableScan [TS_9] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Reducer 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_207] + PartitionCols:_col1 + Filter Operator [FIL_206] (rows=12539214 width=201) + predicate:_col2 is not null + Select Operator [SEL_205] (rows=12539214 width=201) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_204] (rows=12539214 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1 + Group By Operator [GBY_22] (rows=12539214 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_177] (rows=12539214 width=196) + Conds:RS_18._col2=RS_192._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_192] + PartitionCols:_col0 + Select Operator [SEL_189] (rows=40000000 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_186] (rows=40000000 width=90) + predicate:ca_state is not null + Please refer to the previous TableScan [TS_3] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_176] (rows=12539214 width=114) + Conds:RS_198._col0=RS_202._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_198] + PartitionCols:_col0 + Select Operator [SEL_196] (rows=12539214 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_194] (rows=12539214 width=118) + predicate:(wr_returning_customer_sk is not null and wr_returned_date_sk is not null and wr_returning_addr_sk is not null) + Please refer to the previous TableScan [TS_6] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_202] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_201] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query33.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query33.q.out index f00567eeb1..63a5cd9f31 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query33.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query33.q.out @@ -191,224 +191,226 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_357] - Limit [LIM_356] (rows=7 width=116) + File Output Operator [FS_359] + Limit [LIM_358] (rows=7 width=116) Number of rows:100 - Select Operator [SEL_355] (rows=7 width=116) + Select Operator [SEL_357] (rows=7 width=116) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_354] - Group By Operator [GBY_353] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 11 [CONTAINS] vectorized - Reduce Output Operator [RS_373] - PartitionCols:_col0 - Group By Operator [GBY_372] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_371] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_109] - PartitionCols:_col0 - Group By Operator [GBY_108] (rows=8 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_304] (rows=206906 width=96) - Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_104] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_293] (rows=46084 width=7) - Conds:RS_319._col1=RS_325._col0(Inner),Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col1 - Select Operator [SEL_318] (rows=460848 width=7) - Output:["_col0","_col1"] - Filter Operator [FIL_317] (rows=460848 width=7) - predicate:i_manufact_id is not null - TableScan [TS_0] (rows=462000 width=7) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_manufact_id"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_325] - PartitionCols:_col0 - Group By Operator [GBY_324] (rows=69 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Group By Operator [GBY_322] (rows=70 width=4) - Output:["_col0"],keys:i_manufact_id - Select Operator [SEL_321] (rows=46085 width=93) - Output:["i_manufact_id"] - Filter Operator [FIL_320] (rows=46085 width=93) - predicate:((i_category = 'Books') and i_manufact_id is not null) - TableScan [TS_3] (rows=462000 width=93) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_category","i_manufact_id"] - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_105] - PartitionCols:_col2 - Select Operator [SEL_100] (rows=143931246 width=115) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=115) - Conds:RS_97._col2=RS_349._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_349] - PartitionCols:_col0 - Select Operator [SEL_346] (rows=8000000 width=4) - Output:["_col0"] - Filter Operator [FIL_345] (rows=8000000 width=112) - predicate:(ca_gmt_offset = -6) - TableScan [TS_16] (rows=40000000 width=112) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_300] (rows=143931246 width=119) - Conds:RS_370._col0=RS_332._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_332] - PartitionCols:_col0 - Select Operator [SEL_327] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_326] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3)) - TableScan [TS_13] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_370] - PartitionCols:_col0 - Select Operator [SEL_369] (rows=143931246 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_368] (rows=143931246 width=123) - predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_85] (rows=144002668 width=123) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_367] - Group By Operator [GBY_366] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_339] - Group By Operator [GBY_336] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_333] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 4 [CONTAINS] vectorized - Reduce Output Operator [RS_352] - PartitionCols:_col0 - Group By Operator [GBY_351] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_350] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col0 - Group By Operator [GBY_33] (rows=8 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_302] (rows=755172 width=3) - Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_293] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col2 - Select Operator [SEL_25] (rows=525327191 width=110) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=110) - Conds:RS_22._col2=RS_347._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_347] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_294] (rows=525327191 width=114) - Conds:RS_344._col0=RS_328._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_328] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] - PartitionCols:_col0 - Select Operator [SEL_343] (rows=525327191 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_342] (rows=525327191 width=118) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_10] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_341] - Group By Operator [GBY_340] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_337] - Group By Operator [GBY_334] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_329] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_365] - PartitionCols:_col0 - Group By Operator [GBY_364] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_363] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_71] - PartitionCols:_col0 - Group By Operator [GBY_70] (rows=8 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_303] (rows=409865 width=3) - Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_293] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_67] - PartitionCols:_col3 - Select Operator [SEL_62] (rows=285117733 width=115) - Output:["_col3","_col4"] - Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=115) - Conds:RS_59._col1=RS_348._col0(Inner),Output:["_col2","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_59] + SHUFFLE [RS_356] + Top N Key Operator [TNK_355] (rows=7 width=116) + keys:_col1,top n:100 + Group By Operator [GBY_354] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 11 [CONTAINS] vectorized + Reduce Output Operator [RS_375] + PartitionCols:_col0 + Group By Operator [GBY_374] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_373] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_109] + PartitionCols:_col0 + Group By Operator [GBY_108] (rows=8 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_305] (rows=206906 width=96) + Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_104] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_294] (rows=46084 width=7) + Conds:RS_320._col1=RS_326._col0(Inner),Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_320] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_297] (rows=285117733 width=119) - Conds:RS_362._col0=RS_330._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_330] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_362] + Select Operator [SEL_319] (rows=460848 width=7) + Output:["_col0","_col1"] + Filter Operator [FIL_318] (rows=460848 width=7) + predicate:i_manufact_id is not null + TableScan [TS_0] (rows=462000 width=7) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_manufact_id"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_326] + PartitionCols:_col0 + Group By Operator [GBY_325] (rows=69 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_324] PartitionCols:_col0 - Select Operator [SEL_361] (rows=285117733 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_360] (rows=285117733 width=123) - predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_47] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_359] - Group By Operator [GBY_358] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_338] - Group By Operator [GBY_335] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_331] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] + Group By Operator [GBY_323] (rows=70 width=4) + Output:["_col0"],keys:i_manufact_id + Select Operator [SEL_322] (rows=46085 width=93) + Output:["i_manufact_id"] + Filter Operator [FIL_321] (rows=46085 width=93) + predicate:((i_category = 'Books') and i_manufact_id is not null) + TableScan [TS_3] (rows=462000 width=93) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_category","i_manufact_id"] + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_105] + PartitionCols:_col2 + Select Operator [SEL_100] (rows=143931246 width=115) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_302] (rows=143931246 width=115) + Conds:RS_97._col2=RS_350._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_350] + PartitionCols:_col0 + Select Operator [SEL_347] (rows=8000000 width=4) + Output:["_col0"] + Filter Operator [FIL_346] (rows=8000000 width=112) + predicate:(ca_gmt_offset = -6) + TableScan [TS_16] (rows=40000000 width=112) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_97] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=119) + Conds:RS_372._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_333] + PartitionCols:_col0 + Select Operator [SEL_328] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_327] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3)) + TableScan [TS_13] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_372] + PartitionCols:_col0 + Select Operator [SEL_371] (rows=143931246 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_370] (rows=143931246 width=123) + predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_85] (rows=144002668 width=123) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_369] + Group By Operator [GBY_368] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_340] + Group By Operator [GBY_337] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_334] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] + <-Reducer 4 [CONTAINS] vectorized + Reduce Output Operator [RS_353] + PartitionCols:_col0 + Group By Operator [GBY_352] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_351] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col0 + Group By Operator [GBY_33] (rows=8 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_303] (rows=755172 width=3) + Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_294] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col2 + Select Operator [SEL_25] (rows=525327191 width=110) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_296] (rows=525327191 width=110) + Conds:RS_22._col2=RS_348._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_348] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_347] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=114) + Conds:RS_345._col0=RS_329._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_329] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_328] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_345] + PartitionCols:_col0 + Select Operator [SEL_344] (rows=525327191 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_343] (rows=525327191 width=118) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_10] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_342] + Group By Operator [GBY_341] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_338] + Group By Operator [GBY_335] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_330] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] + <-Reducer 9 [CONTAINS] vectorized + Reduce Output Operator [RS_367] + PartitionCols:_col0 + Group By Operator [GBY_366] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_365] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_71] + PartitionCols:_col0 + Group By Operator [GBY_70] (rows=8 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_304] (rows=409865 width=3) + Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_294] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_67] + PartitionCols:_col3 + Select Operator [SEL_62] (rows=285117733 width=115) + Output:["_col3","_col4"] + Merge Join Operator [MERGEJOIN_299] (rows=285117733 width=115) + Conds:RS_59._col1=RS_349._col0(Inner),Output:["_col2","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_347] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_59] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=119) + Conds:RS_364._col0=RS_331._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_331] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_328] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_364] + PartitionCols:_col0 + Select Operator [SEL_363] (rows=285117733 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_362] (rows=285117733 width=123) + predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_47] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 21 [BROADCAST_EDGE] vectorized + BROADCAST [RS_361] + Group By Operator [GBY_360] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_339] + Group By Operator [GBY_336] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_332] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query35.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query35.q.out index 23b3399123..ea0f0b5057 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query35.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query35.q.out @@ -153,82 +153,82 @@ Stage-0 limit:-1 Stage-1 Reducer 8 vectorized - File Output Operator [FS_226] - Limit [LIM_225] (rows=1 width=352) + File Output Operator [FS_231] + Limit [LIM_230] (rows=1 width=352) Number of rows:100 - Select Operator [SEL_224] (rows=1 width=352) + Select Operator [SEL_229] (rows=1 width=352) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] - Select Operator [SEL_222] (rows=1 width=352) + SHUFFLE [RS_228] + Select Operator [SEL_227] (rows=1 width=352) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col12","_col14","_col15","_col16","_col17"] - Group By Operator [GBY_221] (rows=1 width=336) + Group By Operator [GBY_226] (rows=1 width=336) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)","count(VALUE._col2)","max(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","max(VALUE._col6)","sum(VALUE._col7)","count(VALUE._col8)","max(VALUE._col9)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 Group By Operator [GBY_65] (rows=2 width=336) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15"],aggregations:["count()","sum(_col8)","count(_col8)","max(_col8)","sum(_col9)","count(_col9)","max(_col9)","sum(_col10)","count(_col10)","max(_col10)"],keys:_col4, _col6, _col7, _col8, _col9, _col10 - Top N Key Operator [TNK_103] (rows=1401496 width=276) - keys:_col4, _col6, _col7, _col8, _col9, _col10,top n:100 - Select Operator [SEL_64] (rows=1401496 width=276) - Output:["_col4","_col6","_col7","_col8","_col9","_col10"] + Select Operator [SEL_64] (rows=1401496 width=276) + Output:["_col4","_col6","_col7","_col8","_col9","_col10"] + Top N Key Operator [TNK_106] (rows=1401496 width=276) + keys:_col4, _col6, _col7, _col8, _col9, _col10,top n:100 Filter Operator [FIL_63] (rows=1401496 width=276) predicate:(_col11 is not null or _col13 is not null) - Merge Join Operator [MERGEJOIN_181] (rows=1401496 width=276) - Conds:RS_60._col0=RS_220._col1(Left Outer),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col13"] + Merge Join Operator [MERGEJOIN_186] (rows=1401496 width=276) + Conds:RS_60._col0=RS_225._col1(Left Outer),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col13"] <-Reducer 5 [SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_60] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_180] (rows=1414922 width=276) - Conds:RS_57._col0=RS_212._col1(Left Outer),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10","_col11"] + Merge Join Operator [MERGEJOIN_185] (rows=1414922 width=276) + Conds:RS_57._col0=RS_217._col1(Left Outer),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10","_col11"] <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_212] + SHUFFLE [RS_217] PartitionCols:_col1 - Select Operator [SEL_211] (rows=1414922 width=7) + Select Operator [SEL_216] (rows=1414922 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_210] (rows=1414922 width=3) + Group By Operator [GBY_215] (rows=1414922 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_35] PartitionCols:_col0 Group By Operator [GBY_34] (rows=143930993 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_177] (rows=143930993 width=3) - Conds:RS_209._col0=RS_193._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_182] (rows=143930993 width=3) + Conds:RS_214._col0=RS_198._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_193] + SHUFFLE [RS_198] PartitionCols:_col0 - Select Operator [SEL_190] (rows=652 width=4) + Select Operator [SEL_195] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_189] (rows=652 width=12) + Filter Operator [FIL_194] (rows=652 width=12) predicate:((d_year = 1999) and (d_qoy < 4)) TableScan [TS_17] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_209] + SHUFFLE [RS_214] PartitionCols:_col0 - Select Operator [SEL_208] (rows=143930993 width=7) + Select Operator [SEL_213] (rows=143930993 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_207] (rows=143930993 width=7) + Filter Operator [FIL_212] (rows=143930993 width=7) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_31_date_dim_d_date_sk_min) AND DynamicValue(RS_31_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_31_date_dim_d_date_sk_bloom_filter))) TableScan [TS_24] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"] <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_206] - Group By Operator [GBY_205] (rows=1 width=12) + BROADCAST [RS_211] + Group By Operator [GBY_210] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_199] - Group By Operator [GBY_197] (rows=1 width=12) + SHUFFLE [RS_204] + Group By Operator [GBY_202] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_194] (rows=652 width=4) + Select Operator [SEL_199] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_179] (rows=525327388 width=272) + Merge Join Operator [MERGEJOIN_184] (rows=525327388 width=272) Conds:RS_54._col0=RS_55._col0(Left Semi),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_55] @@ -237,103 +237,103 @@ Stage-0 Output:["_col0"],keys:_col0 Select Operator [SEL_23] (rows=525327388 width=3) Output:["_col0"] - Merge Join Operator [MERGEJOIN_176] (rows=525327388 width=3) - Conds:RS_204._col0=RS_191._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_181] (rows=525327388 width=3) + Conds:RS_209._col0=RS_196._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] + SHUFFLE [RS_196] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_204] + SHUFFLE [RS_209] PartitionCols:_col0 - Select Operator [SEL_203] (rows=525327388 width=7) + Select Operator [SEL_208] (rows=525327388 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_202] (rows=525327388 width=7) + Filter Operator [FIL_207] (rows=525327388 width=7) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_21_date_dim_d_date_sk_min) AND DynamicValue(RS_21_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_21_date_dim_d_date_sk_bloom_filter))) TableScan [TS_14] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_201] - Group By Operator [GBY_200] (rows=1 width=12) + BROADCAST [RS_206] + Group By Operator [GBY_205] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] - Group By Operator [GBY_196] (rows=1 width=12) + SHUFFLE [RS_203] + Group By Operator [GBY_201] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_192] (rows=652 width=4) + Select Operator [SEL_197] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_54] PartitionCols:_col0 Select Operator [SEL_13] (rows=78293105 width=272) Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10"] - Merge Join Operator [MERGEJOIN_175] (rows=78293105 width=272) - Conds:RS_10._col2=RS_188._col0(Inner),Output:["_col0","_col4","_col5","_col6","_col7","_col8","_col10"] + Merge Join Operator [MERGEJOIN_180] (rows=78293105 width=272) + Conds:RS_10._col2=RS_193._col0(Inner),Output:["_col0","_col4","_col5","_col6","_col7","_col8","_col10"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_188] + SHUFFLE [RS_193] PartitionCols:_col0 - Select Operator [SEL_187] (rows=40000000 width=90) + Select Operator [SEL_192] (rows=40000000 width=90) Output:["_col0","_col1"] TableScan [TS_5] (rows=40000000 width=90) default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_10] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_174] (rows=78293105 width=190) - Conds:RS_184._col1=RS_186._col0(Inner),Output:["_col0","_col2","_col4","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_179] (rows=78293105 width=190) + Conds:RS_189._col1=RS_191._col0(Inner),Output:["_col0","_col2","_col4","_col5","_col6","_col7","_col8"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_184] + SHUFFLE [RS_189] PartitionCols:_col1 - Select Operator [SEL_183] (rows=77201384 width=11) + Select Operator [SEL_188] (rows=77201384 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_182] (rows=77201384 width=11) + Filter Operator [FIL_187] (rows=77201384 width=11) predicate:(c_current_cdemo_sk is not null and c_current_addr_sk is not null) TableScan [TS_0] (rows=80000000 width=11) default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_186] + SHUFFLE [RS_191] PartitionCols:_col0 - Select Operator [SEL_185] (rows=1861800 width=186) + Select Operator [SEL_190] (rows=1861800 width=186) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] TableScan [TS_3] (rows=1861800 width=186) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_dep_count","cd_dep_employed_count","cd_dep_college_count"] <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_220] + SHUFFLE [RS_225] PartitionCols:_col1 - Select Operator [SEL_219] (rows=1401496 width=7) + Select Operator [SEL_224] (rows=1401496 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_218] (rows=1401496 width=3) + Group By Operator [GBY_223] (rows=1401496 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_49] PartitionCols:_col0 Group By Operator [GBY_48] (rows=285115246 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=285115246 width=3) - Conds:RS_217._col0=RS_195._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_183] (rows=285115246 width=3) + Conds:RS_222._col0=RS_200._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_195] + SHUFFLE [RS_200] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_190] + Please refer to the previous Select Operator [SEL_195] <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_217] + SHUFFLE [RS_222] PartitionCols:_col0 - Select Operator [SEL_216] (rows=285115246 width=7) + Select Operator [SEL_221] (rows=285115246 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_215] (rows=285115246 width=7) + Filter Operator [FIL_220] (rows=285115246 width=7) predicate:(cs_ship_customer_sk is not null and cs_sold_date_sk is not null and cs_ship_customer_sk BETWEEN DynamicValue(RS_60_c_c_customer_sk_min) AND DynamicValue(RS_60_c_c_customer_sk_max) and in_bloom_filter(cs_ship_customer_sk, DynamicValue(RS_60_c_c_customer_sk_bloom_filter))) TableScan [TS_38] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_214] - Group By Operator [GBY_213] (rows=1 width=12) + BROADCAST [RS_219] + Group By Operator [GBY_218] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Reducer 5 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_166] - Group By Operator [GBY_165] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_171] + Group By Operator [GBY_170] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_164] (rows=1414922 width=4) + Select Operator [SEL_169] (rows=1414922 width=4) Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_180] + Please refer to the previous Merge Join Operator [MERGEJOIN_185] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query36.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query36.q.out index f7bccf94f7..9b5dfbcf69 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query36.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query36.q.out @@ -83,88 +83,90 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_107] - Limit [LIM_106] (rows=100 width=490) + File Output Operator [FS_109] + Limit [LIM_108] (rows=100 width=490) Number of rows:100 - Select Operator [SEL_105] (rows=3060 width=490) + Select Operator [SEL_107] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_104] - Select Operator [SEL_103] (rows=3060 width=490) + SHUFFLE [RS_106] + Select Operator [SEL_105] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_102] (rows=3060 width=414) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(_col2 / _col3) ASC NULLS LAST","partition by:":"(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] - Select Operator [SEL_101] (rows=3060 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_100] - PartitionCols:(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END - Select Operator [SEL_99] (rows=3060 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_98] (rows=3060 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_22] (rows=2487780 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1, 0L - Select Operator [SEL_20] (rows=525329897 width=395) - Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=395) - Conds:RS_17._col1=RS_97._col0(Inner),Output:["_col3","_col4","_col8","_col9"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - PartitionCols:_col0 - Select Operator [SEL_96] (rows=462000 width=186) - Output:["_col0","_col1","_col2"] - TableScan [TS_9] (rows=462000 width=186) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_80] (rows=525329897 width=217) - Conds:RS_14._col2=RS_95._col0(Inner),Output:["_col1","_col3","_col4"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_95] - PartitionCols:_col0 - Select Operator [SEL_94] (rows=278 width=4) - Output:["_col0"] - Filter Operator [FIL_93] (rows=278 width=90) - predicate:(s_state) IN ('SD', 'FL', 'MI', 'LA', 'MO', 'SC', 'AL', 'GA') - TableScan [TS_6] (rows=1704 width=90) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_14] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_79] (rows=525329897 width=221) - Conds:RS_92._col0=RS_84._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_84] - PartitionCols:_col0 - Select Operator [SEL_83] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_82] (rows=652 width=8) - predicate:(d_year = 1999) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] - PartitionCols:_col0 - Select Operator [SEL_91] (rows=525329897 width=225) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_90] (rows=525329897 width=225) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_12_d1_d_date_sk_min) AND DynamicValue(RS_12_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_12_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=225) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] - <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_89] - Group By Operator [GBY_88] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_87] - Group By Operator [GBY_86] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_85] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_83] + Top N Key Operator [TNK_104] (rows=3060 width=414) + keys:(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN (((grouping(_col4, 1L) + grouping(_col4, 0L)) = 0L)) THEN (_col0) ELSE (null) END, rank_window_0,top n:100 + PTF Operator [PTF_103] (rows=3060 width=414) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(_col2 / _col3) ASC NULLS LAST","partition by:":"(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] + Select Operator [SEL_102] (rows=3060 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_101] + PartitionCols:(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END + Select Operator [SEL_100] (rows=3060 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"] + Group By Operator [GBY_99] (rows=3060 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_22] (rows=2487780 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1, 0L + Select Operator [SEL_20] (rows=525329897 width=395) + Output:["_col0","_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_82] (rows=525329897 width=395) + Conds:RS_17._col1=RS_98._col0(Inner),Output:["_col3","_col4","_col8","_col9"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_98] + PartitionCols:_col0 + Select Operator [SEL_97] (rows=462000 width=186) + Output:["_col0","_col1","_col2"] + TableScan [TS_9] (rows=462000 width=186) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=217) + Conds:RS_14._col2=RS_96._col0(Inner),Output:["_col1","_col3","_col4"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_96] + PartitionCols:_col0 + Select Operator [SEL_95] (rows=278 width=4) + Output:["_col0"] + Filter Operator [FIL_94] (rows=278 width=90) + predicate:(s_state) IN ('SD', 'FL', 'MI', 'LA', 'MO', 'SC', 'AL', 'GA') + TableScan [TS_6] (rows=1704 width=90) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_14] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_80] (rows=525329897 width=221) + Conds:RS_93._col0=RS_85._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_85] + PartitionCols:_col0 + Select Operator [SEL_84] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_83] (rows=652 width=8) + predicate:(d_year = 1999) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_93] + PartitionCols:_col0 + Select Operator [SEL_92] (rows=525329897 width=225) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_91] (rows=525329897 width=225) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_12_d1_d_date_sk_min) AND DynamicValue(RS_12_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_12_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=225) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] + <-Reducer 9 [BROADCAST_EDGE] vectorized + BROADCAST [RS_90] + Group By Operator [GBY_89] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_88] + Group By Operator [GBY_87] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_86] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_84] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query37.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query37.q.out index 187ad5c5b5..0f16fa1ad1 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query37.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query37.q.out @@ -56,78 +56,78 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_100] - Limit [LIM_99] (rows=4 width=396) + File Output Operator [FS_105] + Limit [LIM_104] (rows=4 width=396) Number of rows:100 - Select Operator [SEL_98] (rows=4 width=396) + Select Operator [SEL_103] (rows=4 width=396) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - Group By Operator [GBY_96] (rows=4 width=396) + SHUFFLE [RS_102] + Group By Operator [GBY_101] (rows=4 width=396) Output:["_col0","_col1","_col2"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_22] (rows=8 width=396) Output:["_col0","_col1","_col2"],keys:_col2, _col3, _col4 - Top N Key Operator [TNK_42] (rows=11627 width=396) + Top N Key Operator [TNK_47] (rows=11627 width=396) keys:_col2, _col3, _col4,top n:100 - Merge Join Operator [MERGEJOIN_78] (rows=11627 width=396) + Merge Join Operator [MERGEJOIN_83] (rows=11627 width=396) Conds:RS_18._col1=RS_19._col1(Inner),Output:["_col2","_col3","_col4"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_76] (rows=1781971 width=400) - Conds:RS_89._col0=RS_81._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_81] (rows=1781971 width=400) + Conds:RS_94._col0=RS_86._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_81] + PARTITION_ONLY_SHUFFLE [RS_86] PartitionCols:_col0 - Select Operator [SEL_80] (rows=297 width=400) + Select Operator [SEL_85] (rows=297 width=400) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_79] (rows=297 width=404) + Filter Operator [FIL_84] (rows=297 width=404) predicate:(i_current_price BETWEEN 22 AND 52 and (i_manufact_id) IN (678, 964, 918, 849)) TableScan [TS_2] (rows=462000 width=403) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_manufact_id"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_89] + SHUFFLE [RS_94] PartitionCols:_col0 - Select Operator [SEL_88] (rows=287989836 width=4) + Select Operator [SEL_93] (rows=287989836 width=4) Output:["_col0"] - Filter Operator [FIL_87] (rows=287989836 width=4) + Filter Operator [FIL_92] (rows=287989836 width=4) predicate:(cs_item_sk BETWEEN DynamicValue(RS_16_item_i_item_sk_min) AND DynamicValue(RS_16_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, DynamicValue(RS_16_item_i_item_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=4) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_item_sk"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_86] - Group By Operator [GBY_85] (rows=1 width=12) + BROADCAST [RS_91] + Group By Operator [GBY_90] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_84] - Group By Operator [GBY_83] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_89] + Group By Operator [GBY_88] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_82] (rows=297 width=4) + Select Operator [SEL_87] (rows=297 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_80] + Please refer to the previous Select Operator [SEL_85] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_77] (rows=1879072 width=4) - Conds:RS_92._col0=RS_95._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_82] (rows=1879072 width=4) + Conds:RS_97._col0=RS_100._col0(Inner),Output:["_col1"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_95] + SHUFFLE [RS_100] PartitionCols:_col0 - Select Operator [SEL_94] (rows=8116 width=4) + Select Operator [SEL_99] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_93] (rows=8116 width=98) + Filter Operator [FIL_98] (rows=8116 width=98) predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-06-02 00:00:00' AND TIMESTAMP'2001-08-01 00:00:00' TableScan [TS_8] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] + SHUFFLE [RS_97] PartitionCols:_col0 - Select Operator [SEL_91] (rows=16912800 width=8) + Select Operator [SEL_96] (rows=16912800 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_90] (rows=16912800 width=11) + Filter Operator [FIL_95] (rows=16912800 width=11) predicate:inv_quantity_on_hand BETWEEN 100 AND 500 TableScan [TS_5] (rows=37584000 width=11) default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_quantity_on_hand"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query4.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query4.q.out index 68796c2274..127bd87bf7 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query4.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query4.q.out @@ -271,353 +271,355 @@ Stage-0 limit:100 Stage-1 Reducer 10 vectorized - File Output Operator [FS_562] - Limit [LIM_561] (rows=100 width=85) + File Output Operator [FS_563] + Limit [LIM_562] (rows=100 width=85) Number of rows:100 - Select Operator [SEL_560] (rows=11399756 width=85) + Select Operator [SEL_561] (rows=11399756 width=85) Output:["_col0"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_135] Select Operator [SEL_134] (rows=11399756 width=85) Output:["_col0"] - Filter Operator [FIL_133] (rows=11399756 width=537) - predicate:CASE WHEN (_col4 is not null) THEN (CASE WHEN (_col7) THEN (((_col9 / _col6) > (_col14 / _col4))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_466] (rows=22799512 width=537) - Conds:RS_130._col3=RS_559._col0(Inner),Output:["_col4","_col6","_col7","_col9","_col13","_col14"] - <-Reducer 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_559] - PartitionCols:_col0 - Select Operator [SEL_558] (rows=80000000 width=297) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_557] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 29 [SIMPLE_EDGE] - SHUFFLE [RS_114] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_113] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_461] (rows=525327388 width=764) - Conds:RS_109._col1=RS_505._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_505] - PartitionCols:_col0 - Select Operator [SEL_504] (rows=80000000 width=656) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - TableScan [TS_104] (rows=80000000 width=656) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] - <-Reducer 28 [SIMPLE_EDGE] - SHUFFLE [RS_109] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_460] (rows=525327388 width=115) - Conds:RS_556._col0=RS_475._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_475] - PartitionCols:_col0 - Select Operator [SEL_471] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_467] (rows=652 width=8) - predicate:(d_year = 2002) - TableScan [TS_101] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_556] - PartitionCols:_col0 - Select Operator [SEL_555] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_554] (rows=525327388 width=435) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_107_date_dim_d_date_sk_min) AND DynamicValue(RS_107_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_107_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_98] (rows=575995635 width=435) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] - <-Reducer 32 [BROADCAST_EDGE] vectorized - BROADCAST [RS_553] - Group By Operator [GBY_552] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_493] - Group By Operator [GBY_487] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_476] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_471] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_130] - PartitionCols:_col3 - Filter Operator [FIL_129] (rows=19066162 width=668) - predicate:CASE WHEN (_col2) THEN (CASE WHEN (_col7) THEN (((_col9 / _col6) > (_col11 / _col1))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_465] (rows=38132324 width=668) - Conds:RS_126._col3=RS_551._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6","_col7","_col9","_col11"] - <-Reducer 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_551] - PartitionCols:_col0 - Select Operator [SEL_550] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_549] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_95] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_94] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_459] (rows=143930993 width=764) - Conds:RS_90._col1=RS_506._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_506] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_504] - <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_90] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_458] (rows=143930993 width=115) - Conds:RS_548._col0=RS_477._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_477] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_471] - <-Map 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_548] - PartitionCols:_col0 - Select Operator [SEL_547] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_546] (rows=143930993 width=455) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_88_date_dim_d_date_sk_min) AND DynamicValue(RS_88_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_88_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_79] (rows=144002668 width=455) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] - <-Reducer 33 [BROADCAST_EDGE] vectorized - BROADCAST [RS_545] - Group By Operator [GBY_544] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_494] - Group By Operator [GBY_488] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_478] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_471] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_126] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_464] (rows=31888273 width=556) - Conds:RS_123._col3=RS_543._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6","_col7","_col9"] - <-Reducer 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_543] - PartitionCols:_col0 - Select Operator [SEL_542] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_541] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_76] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_75] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_457] (rows=285117831 width=764) - Conds:RS_71._col1=RS_507._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_507] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_504] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_71] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_456] (rows=285117831 width=115) - Conds:RS_540._col0=RS_479._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_479] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_471] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_540] - PartitionCols:_col0 - Select Operator [SEL_539] (rows=285117831 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_538] (rows=285117831 width=453) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_69_date_dim_d_date_sk_min) AND DynamicValue(RS_69_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_69_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_60] (rows=287989836 width=453) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] - <-Reducer 34 [BROADCAST_EDGE] vectorized - BROADCAST [RS_537] - Group By Operator [GBY_536] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_495] - Group By Operator [GBY_489] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_480] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_471] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_123] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_463] (rows=26666666 width=444) - Conds:RS_120._col3=RS_535._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6","_col7"] - <-Reducer 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_535] + Top N Key Operator [TNK_250] (rows=11399756 width=537) + keys:_col13,top n:100 + Filter Operator [FIL_133] (rows=11399756 width=537) + predicate:CASE WHEN (_col4 is not null) THEN (CASE WHEN (_col7) THEN (((_col9 / _col6) > (_col14 / _col4))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_467] (rows=22799512 width=537) + Conds:RS_130._col3=RS_560._col0(Inner),Output:["_col4","_col6","_col7","_col9","_col13","_col14"] + <-Reducer 30 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_560] + PartitionCols:_col0 + Select Operator [SEL_559] (rows=80000000 width=297) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_558] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 29 [SIMPLE_EDGE] + SHUFFLE [RS_114] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_113] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_462] (rows=525327388 width=764) + Conds:RS_109._col1=RS_506._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_506] PartitionCols:_col0 - Select Operator [SEL_534] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_533] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_532] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_531] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_56] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_55] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_455] (rows=285117831 width=764) - Conds:RS_51._col1=RS_510._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_510] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_504] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_51] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_454] (rows=285117831 width=115) - Conds:RS_530._col0=RS_485._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_485] - PartitionCols:_col0 - Select Operator [SEL_474] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_470] (rows=652 width=8) - predicate:(d_year = 2001) - Please refer to the previous TableScan [TS_101] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_530] - PartitionCols:_col0 - Select Operator [SEL_529] (rows=285117831 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_528] (rows=285117831 width=453) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_49_date_dim_d_date_sk_min) AND DynamicValue(RS_49_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_49_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_40] (rows=287989836 width=453) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] - <-Reducer 37 [BROADCAST_EDGE] vectorized - BROADCAST [RS_527] - Group By Operator [GBY_526] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_498] - Group By Operator [GBY_492] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_486] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_474] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_120] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_462] (rows=26666666 width=328) - Conds:RS_515._col0=RS_525._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Reducer 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_525] + Select Operator [SEL_505] (rows=80000000 width=656) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + TableScan [TS_104] (rows=80000000 width=656) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] + <-Reducer 28 [SIMPLE_EDGE] + SHUFFLE [RS_109] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_461] (rows=525327388 width=115) + Conds:RS_557._col0=RS_476._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_476] PartitionCols:_col0 - Select Operator [SEL_524] (rows=26666666 width=212) - Output:["_col0","_col1"] - Filter Operator [FIL_523] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_522] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_521] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_36] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_35] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_453] (rows=525327388 width=764) - Conds:RS_31._col1=RS_509._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_509] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_504] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_452] (rows=525327388 width=115) - Conds:RS_520._col0=RS_483._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_483] - PartitionCols:_col0 - Select Operator [SEL_473] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_469] (rows=652 width=8) - predicate:(d_year = 2001) - Please refer to the previous TableScan [TS_101] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_520] - PartitionCols:_col0 - Select Operator [SEL_519] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_518] (rows=525327388 width=435) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_date_dim_d_date_sk_min) AND DynamicValue(RS_29_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=575995635 width=435) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] - <-Reducer 36 [BROADCAST_EDGE] vectorized - BROADCAST [RS_517] - Group By Operator [GBY_516] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_497] - Group By Operator [GBY_491] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_484] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_473] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_515] + Select Operator [SEL_472] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_468] (rows=652 width=8) + predicate:(d_year = 2002) + TableScan [TS_101] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_557] PartitionCols:_col0 - Select Operator [SEL_514] (rows=26666666 width=216) + Select Operator [SEL_556] (rows=525327388 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_513] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_512] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_511] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_16] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_15] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_451] (rows=143930993 width=764) - Conds:RS_11._col1=RS_508._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_508] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_504] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_450] (rows=143930993 width=115) - Conds:RS_503._col0=RS_481._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_481] - PartitionCols:_col0 - Select Operator [SEL_472] (rows=652 width=4) + Filter Operator [FIL_555] (rows=525327388 width=435) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_107_date_dim_d_date_sk_min) AND DynamicValue(RS_107_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_107_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_98] (rows=575995635 width=435) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] + <-Reducer 32 [BROADCAST_EDGE] vectorized + BROADCAST [RS_554] + Group By Operator [GBY_553] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_494] + Group By Operator [GBY_488] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_477] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_472] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_130] + PartitionCols:_col3 + Filter Operator [FIL_129] (rows=19066162 width=668) + predicate:CASE WHEN (_col2) THEN (CASE WHEN (_col7) THEN (((_col9 / _col6) > (_col11 / _col1))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_466] (rows=38132324 width=668) + Conds:RS_126._col3=RS_552._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6","_col7","_col9","_col11"] + <-Reducer 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_552] + PartitionCols:_col0 + Select Operator [SEL_551] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_550] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 25 [SIMPLE_EDGE] + SHUFFLE [RS_95] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_94] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_460] (rows=143930993 width=764) + Conds:RS_90._col1=RS_507._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_507] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_505] + <-Reducer 24 [SIMPLE_EDGE] + SHUFFLE [RS_90] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_459] (rows=143930993 width=115) + Conds:RS_549._col0=RS_478._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_478] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_472] + <-Map 23 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_549] + PartitionCols:_col0 + Select Operator [SEL_548] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_547] (rows=143930993 width=455) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_88_date_dim_d_date_sk_min) AND DynamicValue(RS_88_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_88_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_79] (rows=144002668 width=455) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] + <-Reducer 33 [BROADCAST_EDGE] vectorized + BROADCAST [RS_546] + Group By Operator [GBY_545] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_495] + Group By Operator [GBY_489] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_479] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_468] (rows=652 width=8) - predicate:(d_year = 2001) - Please refer to the previous TableScan [TS_101] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_503] - PartitionCols:_col0 - Select Operator [SEL_502] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_501] (rows=143930993 width=455) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_date_dim_d_date_sk_min) AND DynamicValue(RS_9_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=455) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] - <-Reducer 35 [BROADCAST_EDGE] vectorized - BROADCAST [RS_500] - Group By Operator [GBY_499] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_496] - Group By Operator [GBY_490] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_482] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_472] + Please refer to the previous Select Operator [SEL_472] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_126] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_465] (rows=31888273 width=556) + Conds:RS_123._col3=RS_544._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6","_col7","_col9"] + <-Reducer 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_544] + PartitionCols:_col0 + Select Operator [SEL_543] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_542] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_76] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_75] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_458] (rows=285117831 width=764) + Conds:RS_71._col1=RS_508._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_508] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_505] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_71] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_457] (rows=285117831 width=115) + Conds:RS_541._col0=RS_480._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_480] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_472] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_541] + PartitionCols:_col0 + Select Operator [SEL_540] (rows=285117831 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_539] (rows=285117831 width=453) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_69_date_dim_d_date_sk_min) AND DynamicValue(RS_69_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_69_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_60] (rows=287989836 width=453) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] + <-Reducer 34 [BROADCAST_EDGE] vectorized + BROADCAST [RS_538] + Group By Operator [GBY_537] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_496] + Group By Operator [GBY_490] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_481] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_472] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_123] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_464] (rows=26666666 width=444) + Conds:RS_120._col3=RS_536._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6","_col7"] + <-Reducer 18 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_536] + PartitionCols:_col0 + Select Operator [SEL_535] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_534] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_533] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_532] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 17 [SIMPLE_EDGE] + SHUFFLE [RS_56] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_55] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_456] (rows=285117831 width=764) + Conds:RS_51._col1=RS_511._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_511] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_505] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_51] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_455] (rows=285117831 width=115) + Conds:RS_531._col0=RS_486._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_486] + PartitionCols:_col0 + Select Operator [SEL_475] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_471] (rows=652 width=8) + predicate:(d_year = 2001) + Please refer to the previous TableScan [TS_101] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_531] + PartitionCols:_col0 + Select Operator [SEL_530] (rows=285117831 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_529] (rows=285117831 width=453) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_49_date_dim_d_date_sk_min) AND DynamicValue(RS_49_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_49_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_40] (rows=287989836 width=453) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] + <-Reducer 37 [BROADCAST_EDGE] vectorized + BROADCAST [RS_528] + Group By Operator [GBY_527] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_499] + Group By Operator [GBY_493] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_487] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_475] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_120] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_463] (rows=26666666 width=328) + Conds:RS_516._col0=RS_526._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Reducer 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_526] + PartitionCols:_col0 + Select Operator [SEL_525] (rows=26666666 width=212) + Output:["_col0","_col1"] + Filter Operator [FIL_524] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_523] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_522] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_36] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_35] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_454] (rows=525327388 width=764) + Conds:RS_31._col1=RS_510._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_510] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_505] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_453] (rows=525327388 width=115) + Conds:RS_521._col0=RS_484._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_484] + PartitionCols:_col0 + Select Operator [SEL_474] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_470] (rows=652 width=8) + predicate:(d_year = 2001) + Please refer to the previous TableScan [TS_101] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_521] + PartitionCols:_col0 + Select Operator [SEL_520] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_519] (rows=525327388 width=435) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_date_dim_d_date_sk_min) AND DynamicValue(RS_29_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=575995635 width=435) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] + <-Reducer 36 [BROADCAST_EDGE] vectorized + BROADCAST [RS_518] + Group By Operator [GBY_517] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_498] + Group By Operator [GBY_492] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_485] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_474] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_516] + PartitionCols:_col0 + Select Operator [SEL_515] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_514] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_513] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_512] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_16] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_15] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_452] (rows=143930993 width=764) + Conds:RS_11._col1=RS_509._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_509] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_505] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_451] (rows=143930993 width=115) + Conds:RS_504._col0=RS_482._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_482] + PartitionCols:_col0 + Select Operator [SEL_473] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_469] (rows=652 width=8) + predicate:(d_year = 2001) + Please refer to the previous TableScan [TS_101] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_504] + PartitionCols:_col0 + Select Operator [SEL_503] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_502] (rows=143930993 width=455) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_date_dim_d_date_sk_min) AND DynamicValue(RS_9_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=455) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] + <-Reducer 35 [BROADCAST_EDGE] vectorized + BROADCAST [RS_501] + Group By Operator [GBY_500] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_497] + Group By Operator [GBY_491] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_483] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_473] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query40.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query40.q.out index 070b5cb1f5..fc1f190d02 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query40.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query40.q.out @@ -81,90 +81,90 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_122] - Limit [LIM_121] (rows=100 width=410) + File Output Operator [FS_127] + Limit [LIM_126] (rows=100 width=410) Number of rows:100 - Select Operator [SEL_120] (rows=769995 width=410) + Select Operator [SEL_125] (rows=769995 width=410) Output:["_col0","_col1","_col2","_col3"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_119] - Group By Operator [GBY_118] (rows=769995 width=410) + SHUFFLE [RS_124] + Group By Operator [GBY_123] (rows=769995 width=410) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col0, _col1 Group By Operator [GBY_27] (rows=51819042 width=410) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1 - Top N Key Operator [TNK_53] (rows=51819042 width=302) - keys:_col0, _col1,top n:100 - Select Operator [SEL_25] (rows=51819042 width=302) - Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_99] (rows=51819042 width=302) - Conds:RS_22._col1=RS_117._col0(Inner),Output:["_col4","_col7","_col9","_col10","_col12","_col14"] + Select Operator [SEL_25] (rows=51819042 width=302) + Output:["_col0","_col1","_col2","_col3"] + Top N Key Operator [TNK_56] (rows=51819042 width=302) + keys:_col14, _col12,top n:100 + Merge Join Operator [MERGEJOIN_104] (rows=51819042 width=302) + Conds:RS_22._col1=RS_122._col0(Inner),Output:["_col4","_col7","_col9","_col10","_col12","_col14"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] + SHUFFLE [RS_122] PartitionCols:_col0 - Select Operator [SEL_116] (rows=27 width=90) + Select Operator [SEL_121] (rows=27 width=90) Output:["_col0","_col1"] TableScan [TS_11] (rows=27 width=90) default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_state"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_98] (rows=51819042 width=220) - Conds:RS_19._col2=RS_102._col0(Inner),Output:["_col1","_col4","_col7","_col9","_col10","_col12"] + Merge Join Operator [MERGEJOIN_103] (rows=51819042 width=220) + Conds:RS_19._col2=RS_107._col0(Inner),Output:["_col1","_col4","_col7","_col9","_col10","_col12"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_102] + SHUFFLE [RS_107] PartitionCols:_col0 - Select Operator [SEL_101] (rows=51333 width=104) + Select Operator [SEL_106] (rows=51333 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_100] (rows=51333 width=215) + Filter Operator [FIL_105] (rows=51333 width=215) predicate:i_current_price BETWEEN 0.99 AND 1.49 TableScan [TS_8] (rows=462000 width=215) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_current_price"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_97] (rows=466374405 width=171) - Conds:RS_16._col0=RS_115._col0(Inner),Output:["_col1","_col2","_col4","_col7","_col9","_col10"] + Merge Join Operator [MERGEJOIN_102] (rows=466374405 width=171) + Conds:RS_16._col0=RS_120._col0(Inner),Output:["_col1","_col2","_col4","_col7","_col9","_col10"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_115] + SHUFFLE [RS_120] PartitionCols:_col0 - Select Operator [SEL_114] (rows=8116 width=12) + Select Operator [SEL_119] (rows=8116 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_113] (rows=8116 width=98) + Filter Operator [FIL_118] (rows=8116 width=98) predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-03-09 00:00:00' AND TIMESTAMP'1998-05-08 00:00:00' TableScan [TS_5] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_16] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_96] (rows=466374405 width=167) - Conds:RS_110._col2, _col3=RS_112._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col7"] + Merge Join Operator [MERGEJOIN_101] (rows=466374405 width=167) + Conds:RS_115._col2, _col3=RS_117._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col7"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_110] + SHUFFLE [RS_115] PartitionCols:_col2, _col3 - Select Operator [SEL_109] (rows=285115816 width=127) + Select Operator [SEL_114] (rows=285115816 width=127) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_108] (rows=285115816 width=127) + Filter Operator [FIL_113] (rows=285115816 width=127) predicate:(cs_warehouse_sk is not null and cs_sold_date_sk is not null and cs_item_sk BETWEEN DynamicValue(RS_20_item_i_item_sk_min) AND DynamicValue(RS_20_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, DynamicValue(RS_20_item_i_item_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=127) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_warehouse_sk","cs_item_sk","cs_order_number","cs_sales_price"] <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_107] - Group By Operator [GBY_106] (rows=1 width=12) + BROADCAST [RS_112] + Group By Operator [GBY_111] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_105] - Group By Operator [GBY_104] (rows=1 width=12) + SHUFFLE [RS_110] + Group By Operator [GBY_109] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_103] (rows=51333 width=4) + Select Operator [SEL_108] (rows=51333 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_101] + Please refer to the previous Select Operator [SEL_106] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_112] + SHUFFLE [RS_117] PartitionCols:_col0, _col1 - Select Operator [SEL_111] (rows=28798881 width=117) + Select Operator [SEL_116] (rows=28798881 width=117) Output:["_col0","_col1","_col2"] TableScan [TS_3] (rows=28798881 width=117) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_refunded_cash"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query42.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query42.q.out index b2dc7b3a8a..b29b8e5c4b 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query42.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query42.q.out @@ -63,65 +63,67 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Limit [LIM_73] (rows=100 width=210) + File Output Operator [FS_76] + Limit [LIM_75] (rows=100 width=210) Number of rows:100 - Select Operator [SEL_72] (rows=110 width=210) + Select Operator [SEL_74] (rows=110 width=210) Output:["_col0","_col1","_col2","_col3"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - Select Operator [SEL_70] (rows=110 width=318) + SHUFFLE [RS_73] + Select Operator [SEL_72] (rows=110 width=318) Output:["_col0","_col1","_col3"] - Group By Operator [GBY_69] (rows=110 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1 - Group By Operator [GBY_16] (rows=6840 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 - Merge Join Operator [MERGEJOIN_54] (rows=84037218 width=173) - Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_68] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=7333 width=97) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_66] (rows=7333 width=101) - predicate:(i_manager_id = 1) - TableScan [TS_6] (rows=462000 width=101) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category_id","i_category","i_manager_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_53] (rows=550076554 width=110) - Conds:RS_65._col0=RS_57._col0(Inner),Output:["_col1","_col2"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_57] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_55] (rows=50 width=12) - predicate:((d_year = 1998) and (d_moy = 12)) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_63] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_62] - Group By Operator [GBY_61] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_60] - Group By Operator [GBY_59] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_58] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_56] + Top N Key Operator [TNK_71] (rows=110 width=206) + keys:_col2, _col0, _col1,top n:100 + Group By Operator [GBY_70] (rows=110 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1 + Group By Operator [GBY_16] (rows=6840 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 + Merge Join Operator [MERGEJOIN_55] (rows=84037218 width=173) + Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] + PartitionCols:_col0 + Select Operator [SEL_68] (rows=7333 width=97) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_67] (rows=7333 width=101) + predicate:(i_manager_id = 1) + TableScan [TS_6] (rows=462000 width=101) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category_id","i_category","i_manager_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_54] (rows=550076554 width=110) + Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_56] (rows=50 width=12) + predicate:((d_year = 1998) and (d_moy = 12)) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query43.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query43.q.out index b5a6c746d1..487e2948b4 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query43.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query43.q.out @@ -57,67 +57,69 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Limit [LIM_73] (rows=100 width=972) + File Output Operator [FS_80] + Limit [LIM_79] (rows=100 width=972) Number of rows:100 - Select Operator [SEL_72] (rows=3751 width=972) + Select Operator [SEL_78] (rows=3751 width=972) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - Group By Operator [GBY_70] (rows=3751 width=972) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col0, _col1 - Group By Operator [GBY_17] (rows=2486913 width=972) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 - Top N Key Operator [TNK_33] (rows=525329897 width=322) - keys:_col0, _col1,top n:100 + SHUFFLE [RS_77] + Top N Key Operator [TNK_76] (rows=3751 width=972) + keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8,top n:100 + Group By Operator [GBY_75] (rows=3751 width=972) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0, _col1 + Group By Operator [GBY_17] (rows=2486913 width=972) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 Select Operator [SEL_15] (rows=525329897 width=322) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_55] (rows=525329897 width=322) - Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col12","_col13"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=341 width=192) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_67] (rows=341 width=303) - predicate:(s_gmt_offset = -6) - TableScan [TS_6] (rows=1704 width=303) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name","s_gmt_offset"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_54] (rows=525329897 width=138) - Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_58] - PartitionCols:_col0 - Select Operator [SEL_57] (rows=652 width=32) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_56] (rows=652 width=99) - predicate:(d_year = 1998) - TableScan [TS_3] (rows=73049 width=99) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_day_name"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_66] - PartitionCols:_col0 - Select Operator [SEL_65] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_64] (rows=525329897 width=114) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_63] - Group By Operator [GBY_62] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_61] - Group By Operator [GBY_60] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_59] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_57] + Top N Key Operator [TNK_36] (rows=525329897 width=322) + keys:_col13, _col12,top n:100 + Merge Join Operator [MERGEJOIN_60] (rows=525329897 width=322) + Conds:RS_12._col1=RS_74._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col12","_col13"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_74] + PartitionCols:_col0 + Select Operator [SEL_73] (rows=341 width=192) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_72] (rows=341 width=303) + predicate:(s_gmt_offset = -6) + TableScan [TS_6] (rows=1704 width=303) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name","s_gmt_offset"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_59] (rows=525329897 width=138) + Conds:RS_71._col0=RS_63._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_62] (rows=652 width=32) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_61] (rows=652 width=99) + predicate:(d_year = 1998) + TableScan [TS_3] (rows=73049 width=99) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_day_name"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_71] + PartitionCols:_col0 + Select Operator [SEL_70] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_69] (rows=525329897 width=114) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_68] + Group By Operator [GBY_67] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_66] + Group By Operator [GBY_65] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_64] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_62] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query44.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query44.q.out index 7644f5ec61..eace7a0685 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query44.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query44.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[109][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[110][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product PREHOOK: query: explain select asceding.rnk, i1.i_product_name best_performing, i2.i_product_name worst_performing from(select * @@ -91,109 +91,111 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_146] - Limit [LIM_145] (rows=100 width=218) + File Output Operator [FS_147] + Limit [LIM_146] (rows=100 width=218) Number of rows:100 - Select Operator [SEL_144] (rows=6951 width=218) + Select Operator [SEL_145] (rows=6951 width=218) Output:["_col0","_col1","_col2"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_70] Select Operator [SEL_69] (rows=6951 width=218) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_113] (rows=6951 width=218) - Conds:RS_66._col2=RS_143._col0(Inner),Output:["_col1","_col5","_col7"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_143] - PartitionCols:_col0 - Select Operator [SEL_141] (rows=462000 width=111) - Output:["_col0","_col1"] - TableScan [TS_56] (rows=462000 width=111) - default@item,i1,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_product_name"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_112] (rows=6951 width=115) - Conds:RS_63._col0=RS_142._col0(Inner),Output:["_col1","_col2","_col5"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_142] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_141] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_111] (rows=6951 width=12) - Conds:RS_135._col1=RS_140._col1(Inner),Output:["_col0","_col1","_col2"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_135] - PartitionCols:_col1 - Select Operator [SEL_134] (rows=6951 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_133] (rows=6951 width=116) - predicate:(rank_window_0 < 11) - PTF Operator [PTF_132] (rows=20854 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_131] (rows=20854 width=116) - Output:["_col0","_col1"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:0 - Filter Operator [FIL_20] (rows=20854 width=228) - predicate:(_col1 > (0.9 * _col2)) - Merge Join Operator [MERGEJOIN_109] (rows=62562 width=228) - Conds:(Inner),Output:["_col0","_col1","_col2"] - <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_130] - Select Operator [SEL_129] (rows=1 width=112) - Output:["_col0"] - Filter Operator [FIL_128] (rows=1 width=120) - predicate:(_col1 is not null and _col2 is not null) - Select Operator [SEL_127] (rows=1 width=120) - Output:["_col1","_col2"] - Group By Operator [GBY_126] (rows=1 width=124) + Top N Key Operator [TNK_99] (rows=6951 width=218) + keys:_col1,top n:100 + Merge Join Operator [MERGEJOIN_114] (rows=6951 width=218) + Conds:RS_66._col2=RS_144._col0(Inner),Output:["_col1","_col5","_col7"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_144] + PartitionCols:_col0 + Select Operator [SEL_142] (rows=462000 width=111) + Output:["_col0","_col1"] + TableScan [TS_56] (rows=462000 width=111) + default@item,i1,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_product_name"] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_113] (rows=6951 width=115) + Conds:RS_63._col0=RS_143._col0(Inner),Output:["_col1","_col2","_col5"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_143] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_142] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_112] (rows=6951 width=12) + Conds:RS_136._col1=RS_141._col1(Inner),Output:["_col0","_col1","_col2"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_136] + PartitionCols:_col1 + Select Operator [SEL_135] (rows=6951 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_134] (rows=6951 width=116) + predicate:(rank_window_0 < 11) + PTF Operator [PTF_133] (rows=20854 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"0"}] + Select Operator [SEL_132] (rows=20854 width=116) + Output:["_col0","_col1"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:0 + Filter Operator [FIL_20] (rows=20854 width=228) + predicate:(_col1 > (0.9 * _col2)) + Merge Join Operator [MERGEJOIN_110] (rows=62562 width=228) + Conds:(Inner),Output:["_col0","_col1","_col2"] + <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_131] + Select Operator [SEL_130] (rows=1 width=112) + Output:["_col0"] + Filter Operator [FIL_129] (rows=1 width=120) + predicate:(_col1 is not null and _col2 is not null) + Select Operator [SEL_128] (rows=1 width=120) + Output:["_col1","_col2"] + Group By Operator [GBY_127] (rows=1 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_126] + PartitionCols:_col0 + Group By Operator [GBY_125] (rows=258 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","count(_col1)"],keys:true + Select Operator [SEL_124] (rows=287946 width=114) + Output:["_col1"] + Filter Operator [FIL_123] (rows=287946 width=114) + predicate:(ss_hdemo_sk is null and (ss_store_sk = 410)) + TableScan [TS_8] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_hdemo_sk","ss_store_sk","ss_net_profit"] + <-Reducer 2 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_122] + Select Operator [SEL_121] (rows=62562 width=116) + Output:["_col0","_col1"] + Filter Operator [FIL_120] (rows=62562 width=124) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_119] (rows=62562 width=124) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_125] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_118] PartitionCols:_col0 - Group By Operator [GBY_124] (rows=258 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","count(_col1)"],keys:true - Select Operator [SEL_123] (rows=287946 width=114) - Output:["_col1"] - Filter Operator [FIL_122] (rows=287946 width=114) - predicate:(ss_hdemo_sk is null and (ss_store_sk = 410)) - TableScan [TS_8] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_hdemo_sk","ss_store_sk","ss_net_profit"] - <-Reducer 2 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_121] - Select Operator [SEL_120] (rows=62562 width=116) - Output:["_col0","_col1"] - Filter Operator [FIL_119] (rows=62562 width=124) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_118] (rows=62562 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] - PartitionCols:_col0 - Group By Operator [GBY_116] (rows=3199976 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(ss_net_profit)","count(ss_net_profit)"],keys:ss_item_sk - Select Operator [SEL_115] (rows=6399952 width=114) - Output:["ss_item_sk","ss_net_profit"] - Filter Operator [FIL_114] (rows=6399952 width=114) - predicate:(ss_store_sk = 410) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,ss1,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_store_sk","ss_net_profit"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_140] - PartitionCols:_col1 - Select Operator [SEL_139] (rows=6951 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_138] (rows=6951 width=116) - predicate:(rank_window_0 < 11) - PTF Operator [PTF_137] (rows=20854 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_136] (rows=20854 width=116) - Output:["_col0","_col1"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_49] - PartitionCols:0 - Please refer to the previous Filter Operator [FIL_20] + Group By Operator [GBY_117] (rows=3199976 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(ss_net_profit)","count(ss_net_profit)"],keys:ss_item_sk + Select Operator [SEL_116] (rows=6399952 width=114) + Output:["ss_item_sk","ss_net_profit"] + Filter Operator [FIL_115] (rows=6399952 width=114) + predicate:(ss_store_sk = 410) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,ss1,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_store_sk","ss_net_profit"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_141] + PartitionCols:_col1 + Select Operator [SEL_140] (rows=6951 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_139] (rows=6951 width=116) + predicate:(rank_window_0 < 11) + PTF Operator [PTF_138] (rows=20854 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"0"}] + Select Operator [SEL_137] (rows=20854 width=116) + Output:["_col0","_col1"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_49] + PartitionCols:0 + Please refer to the previous Filter Operator [FIL_20] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query45.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query45.q.out index 3f5dbf4beb..15953f98c0 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query45.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query45.q.out @@ -67,116 +67,116 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_149] - Limit [LIM_148] (rows=100 width=299) + File Output Operator [FS_154] + Limit [LIM_153] (rows=100 width=299) Number of rows:100 - Select Operator [SEL_147] (rows=17401956 width=299) + Select Operator [SEL_152] (rows=17401956 width=299) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - Group By Operator [GBY_145] (rows=17401956 width=299) + SHUFFLE [RS_151] + Group By Operator [GBY_150] (rows=17401956 width=299) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_41] PartitionCols:_col0, _col1 Group By Operator [GBY_40] (rows=143930993 width=299) Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col8, _col7 - Top N Key Operator [TNK_69] (rows=143930993 width=302) - keys:_col8, _col7,top n:100 - Select Operator [SEL_39] (rows=143930993 width=302) - Output:["_col3","_col7","_col8"] + Select Operator [SEL_39] (rows=143930993 width=302) + Output:["_col3","_col7","_col8"] + Top N Key Operator [TNK_72] (rows=143930993 width=302) + keys:_col8, _col7,top n:100 Filter Operator [FIL_38] (rows=143930993 width=302) predicate:(_col15 is not null or (substr(_col8, 1, 5)) IN ('85669', '86197', '88274', '83405', '86475', '85392', '85460', '80348', '81792')) Select Operator [SEL_37] (rows=143930993 width=302) Output:["_col3","_col7","_col8","_col15"] - Merge Join Operator [MERGEJOIN_119] (rows=143930993 width=302) + Merge Join Operator [MERGEJOIN_124] (rows=143930993 width=302) Conds:RS_34._col0=RS_35._col6(Inner),Output:["_col3","_col7","_col8","_col12"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_34] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_115] (rows=462007 width=4) - Conds:RS_122._col1=RS_128._col0(Left Outer),Output:["_col0","_col3"] + Merge Join Operator [MERGEJOIN_120] (rows=462007 width=4) + Conds:RS_127._col1=RS_133._col0(Left Outer),Output:["_col0","_col3"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_122] + SHUFFLE [RS_127] PartitionCols:_col1 - Select Operator [SEL_120] (rows=462000 width=104) + Select Operator [SEL_125] (rows=462000 width=104) Output:["_col0","_col1"] TableScan [TS_0] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_128] + SHUFFLE [RS_133] PartitionCols:_col0 - Select Operator [SEL_127] (rows=5 width=104) + Select Operator [SEL_132] (rows=5 width=104) Output:["_col0","_col1"] - Group By Operator [GBY_126] (rows=5 width=100) + Group By Operator [GBY_131] (rows=5 width=100) Output:["_col0"],keys:KEY._col0 <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_125] + SHUFFLE [RS_130] PartitionCols:_col0 - Group By Operator [GBY_124] (rows=5 width=100) + Group By Operator [GBY_129] (rows=5 width=100) Output:["_col0"],keys:i_item_id - Select Operator [SEL_123] (rows=11 width=104) + Select Operator [SEL_128] (rows=11 width=104) Output:["i_item_id"] - Filter Operator [FIL_121] (rows=11 width=104) + Filter Operator [FIL_126] (rows=11 width=104) predicate:(i_item_sk) IN (2, 3, 5, 7, 11, 13, 17, 19, 23, 29) Please refer to the previous TableScan [TS_0] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_35] PartitionCols:_col6 - Merge Join Operator [MERGEJOIN_118] (rows=143930993 width=302) + Merge Join Operator [MERGEJOIN_123] (rows=143930993 width=302) Conds:RS_27._col0=RS_28._col2(Inner),Output:["_col3","_col4","_col6","_col8"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_117] (rows=143930993 width=119) - Conds:RS_144._col0=RS_136._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_122] (rows=143930993 width=119) + Conds:RS_149._col0=RS_141._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_136] + PARTITION_ONLY_SHUFFLE [RS_141] PartitionCols:_col0 - Select Operator [SEL_135] (rows=130 width=12) + Select Operator [SEL_140] (rows=130 width=12) Output:["_col0"] - Filter Operator [FIL_134] (rows=130 width=12) + Filter Operator [FIL_139] (rows=130 width=12) predicate:((d_year = 2000) and (d_qoy = 2)) TableScan [TS_17] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] + SHUFFLE [RS_149] PartitionCols:_col0 - Select Operator [SEL_143] (rows=143930993 width=123) + Select Operator [SEL_148] (rows=143930993 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_142] (rows=143930993 width=123) + Filter Operator [FIL_147] (rows=143930993 width=123) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_21_date_dim_d_date_sk_min) AND DynamicValue(RS_21_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_21_date_dim_d_date_sk_bloom_filter))) TableScan [TS_14] (rows=144002668 width=123) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_sales_price"] <-Reducer 14 [BROADCAST_EDGE] vectorized - BROADCAST [RS_141] - Group By Operator [GBY_140] (rows=1 width=12) + BROADCAST [RS_146] + Group By Operator [GBY_145] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_139] - Group By Operator [GBY_138] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_144] + Group By Operator [GBY_143] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_137] (rows=130 width=4) + Select Operator [SEL_142] (rows=130 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_135] + Please refer to the previous Select Operator [SEL_140] <-Reducer 8 [SIMPLE_EDGE] SHUFFLE [RS_27] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_116] (rows=80000000 width=191) - Conds:RS_131._col1=RS_133._col0(Inner),Output:["_col0","_col3","_col4"] + Merge Join Operator [MERGEJOIN_121] (rows=80000000 width=191) + Conds:RS_136._col1=RS_138._col0(Inner),Output:["_col0","_col3","_col4"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_133] + SHUFFLE [RS_138] PartitionCols:_col0 - Select Operator [SEL_132] (rows=40000000 width=191) + Select Operator [SEL_137] (rows=40000000 width=191) Output:["_col0","_col1","_col2"] TableScan [TS_12] (rows=40000000 width=191) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_zip"] <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_131] + SHUFFLE [RS_136] PartitionCols:_col1 - Select Operator [SEL_130] (rows=80000000 width=8) + Select Operator [SEL_135] (rows=80000000 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_129] (rows=80000000 width=8) + Filter Operator [FIL_134] (rows=80000000 width=8) predicate:c_current_addr_sk is not null TableScan [TS_9] (rows=80000000 width=8) default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query46.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query46.q.out index 804013fb80..fcf414ca70 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query46.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query46.q.out @@ -99,118 +99,120 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_172] - Limit [LIM_171] (rows=100 width=594) + File Output Operator [FS_173] + Limit [LIM_172] (rows=100 width=594) Number of rows:100 - Select Operator [SEL_170] (rows=457565061 width=594) + Select Operator [SEL_171] (rows=457565061 width=594) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_44] Select Operator [SEL_43] (rows=457565061 width=594) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_42] (rows=457565061 width=594) - predicate:(_col5 <> _col8) - Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=594) - Conds:RS_39._col0=RS_169._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_39] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_138] (rows=80000000 width=277) - Conds:RS_146._col1=RS_148._col0(Inner),Output:["_col0","_col2","_col3","_col5"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=40000000 width=97) - Output:["_col0","_col1"] - TableScan [TS_3] (rows=40000000 width=97) - default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - PartitionCols:_col1 - Select Operator [SEL_145] (rows=80000000 width=188) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_144] (rows=80000000 width=188) - predicate:c_current_addr_sk is not null - TableScan [TS_0] (rows=80000000 width=188) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] - <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_169] - PartitionCols:_col1 - Select Operator [SEL_168] (rows=457565061 width=324) - Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_167] (rows=457565061 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_32] (rows=457565061 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col12, _col3, _col5 - Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=318) - Conds:RS_28._col3=RS_149._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col12"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_149] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_147] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_28] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_141] (rows=457565061 width=225) - Conds:RS_25._col2=RS_166._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_166] - PartitionCols:_col0 - Select Operator [SEL_165] (rows=1855 width=4) - Output:["_col0"] - Filter Operator [FIL_164] (rows=1855 width=12) - predicate:((hd_vehicle_count = 1) or (hd_dep_count = 2)) - TableScan [TS_14] (rows=7200 width=12) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_25] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_140] (rows=457565061 width=229) - Conds:RS_22._col4=RS_163._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] - PartitionCols:_col0 - Select Operator [SEL_162] (rows=35 width=4) - Output:["_col0"] - Filter Operator [FIL_161] (rows=35 width=97) - predicate:(s_city) IN ('Cedar Grove', 'Wildwood', 'Union', 'Salem', 'Highland Park') - TableScan [TS_11] (rows=1704 width=97) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_139] (rows=457565061 width=233) - Conds:RS_160._col0=RS_152._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_152] - PartitionCols:_col0 - Select Operator [SEL_151] (rows=783 width=4) - Output:["_col0"] - Filter Operator [FIL_150] (rows=783 width=12) - predicate:((d_year) IN (1998, 1999, 2000) and (d_dow) IN (6, 0)) - TableScan [TS_8] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_160] - PartitionCols:_col0 - Select Operator [SEL_159] (rows=457565061 width=237) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_158] (rows=457565061 width=237) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_5] (rows=575995635 width=237) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_157] - Group By Operator [GBY_156] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_155] - Group By Operator [GBY_154] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_153] (rows=783 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_151] + Top N Key Operator [TNK_78] (rows=457565061 width=594) + keys:_col3, _col2, _col5, _col8, _col6,top n:100 + Filter Operator [FIL_42] (rows=457565061 width=594) + predicate:(_col5 <> _col8) + Merge Join Operator [MERGEJOIN_144] (rows=457565061 width=594) + Conds:RS_39._col0=RS_170._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_39] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_139] (rows=80000000 width=277) + Conds:RS_147._col1=RS_149._col0(Inner),Output:["_col0","_col2","_col3","_col5"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=40000000 width=97) + Output:["_col0","_col1"] + TableScan [TS_3] (rows=40000000 width=97) + default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_147] + PartitionCols:_col1 + Select Operator [SEL_146] (rows=80000000 width=188) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_145] (rows=80000000 width=188) + predicate:c_current_addr_sk is not null + TableScan [TS_0] (rows=80000000 width=188) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] + <-Reducer 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_170] + PartitionCols:_col1 + Select Operator [SEL_169] (rows=457565061 width=324) + Output:["_col0","_col1","_col2","_col3","_col4"] + Group By Operator [GBY_168] (rows=457565061 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_32] (rows=457565061 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col12, _col3, _col5 + Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=318) + Conds:RS_28._col3=RS_150._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col12"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_150] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_148] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_28] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=225) + Conds:RS_25._col2=RS_167._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_167] + PartitionCols:_col0 + Select Operator [SEL_166] (rows=1855 width=4) + Output:["_col0"] + Filter Operator [FIL_165] (rows=1855 width=12) + predicate:((hd_vehicle_count = 1) or (hd_dep_count = 2)) + TableScan [TS_14] (rows=7200 width=12) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_25] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_141] (rows=457565061 width=229) + Conds:RS_22._col4=RS_164._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_164] + PartitionCols:_col0 + Select Operator [SEL_163] (rows=35 width=4) + Output:["_col0"] + Filter Operator [FIL_162] (rows=35 width=97) + predicate:(s_city) IN ('Cedar Grove', 'Wildwood', 'Union', 'Salem', 'Highland Park') + TableScan [TS_11] (rows=1704 width=97) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_140] (rows=457565061 width=233) + Conds:RS_161._col0=RS_153._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_153] + PartitionCols:_col0 + Select Operator [SEL_152] (rows=783 width=4) + Output:["_col0"] + Filter Operator [FIL_151] (rows=783 width=12) + predicate:((d_year) IN (1998, 1999, 2000) and (d_dow) IN (6, 0)) + TableScan [TS_8] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_161] + PartitionCols:_col0 + Select Operator [SEL_160] (rows=457565061 width=237) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_159] (rows=457565061 width=237) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_5] (rows=575995635 width=237) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_158] + Group By Operator [GBY_157] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_156] + Group By Operator [GBY_155] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_154] (rows=783 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_152] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query47.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query47.q.out index 701861a888..97ac79bd3c 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query47.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query47.q.out @@ -129,138 +129,140 @@ Stage-0 limit:-1 Stage-1 Reducer 8 vectorized - File Output Operator [FS_321] - Limit [LIM_320] (rows=100 width=658) + File Output Operator [FS_322] + Limit [LIM_321] (rows=100 width=658) Number of rows:100 - Select Operator [SEL_319] (rows=301730 width=658) + Select Operator [SEL_320] (rows=301730 width=658) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_110] Select Operator [SEL_109] (rows=301730 width=658) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_278] (rows=301730 width=546) - Conds:RS_106._col6, _col7, _col8, _col9, _col14=RS_306._col0, _col1, _col2, _col3, _col5(Inner),Output:["_col4","_col6","_col10","_col11","_col12","_col13","_col19"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_306] - PartitionCols:_col0, _col1, _col2, _col3, _col5 - Select Operator [SEL_304] (rows=1810380 width=485) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_302] (rows=1810380 width=489) - predicate:rank_window_0 is not null - PTF Operator [PTF_300] (rows=1810380 width=489) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col5, _col4, _col2, _col3"}] - Select Operator [SEL_299] (rows=1810380 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_297] - PartitionCols:_col5, _col4, _col2, _col3 - Group By Operator [GBY_296] (rows=1810380 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_93] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_92] (rows=525329897 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col8, _col9, _col11, _col12 - Merge Join Operator [MERGEJOIN_276] (rows=525329897 width=483) - Conds:RS_88._col1=RS_295._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col11","_col12"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_295] - PartitionCols:_col0 - Select Operator [SEL_294] (rows=462000 width=194) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_293] (rows=462000 width=194) - predicate:(i_category is not null and i_brand is not null) - TableScan [TS_79] (rows=462000 width=194) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_275] (rows=525329897 width=297) - Conds:RS_85._col2=RS_292._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col8","_col9"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_292] - PartitionCols:_col0 - Select Operator [SEL_291] (rows=1704 width=183) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_290] (rows=1704 width=183) - predicate:(s_store_name is not null and s_company_name is not null) - TableScan [TS_76] (rows=1704 width=183) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_274] (rows=525329897 width=122) - Conds:RS_289._col0=RS_281._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] - PartitionCols:_col0 - Select Operator [SEL_280] (rows=564 width=12) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_279] (rows=564 width=12) - predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1)))) - TableScan [TS_73] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_289] - PartitionCols:_col0 - Select Operator [SEL_288] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_287] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_70] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_286] - Group By Operator [GBY_285] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] - Group By Operator [GBY_283] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_282] (rows=564 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_280] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col6, _col7, _col8, _col9, _col14 - Merge Join Operator [MERGEJOIN_277] (rows=301730 width=717) - Conds:RS_307._col0, _col1, _col2, _col3, _col5=RS_318._col0, _col1, _col2, _col3, _col8(Inner),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_307] - PartitionCols:_col0, _col1, _col2, _col3, _col5 - Select Operator [SEL_305] (rows=1810380 width=485) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_303] (rows=1810380 width=489) - predicate:rank_window_0 is not null - PTF Operator [PTF_301] (rows=1810380 width=489) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col5, _col4, _col2, _col3"}] - Please refer to the previous Select Operator [SEL_299] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] - PartitionCols:_col0, _col1, _col2, _col3, _col8 - Select Operator [SEL_317] (rows=301730 width=605) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_316] (rows=301730 width=605) - predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col7 - _col0)) / _col0) > 0.1)) ELSE (false) END - Select Operator [SEL_315] (rows=603460 width=601) - Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_314] (rows=603460 width=601) - predicate:((_col0 > 0) and rank_window_1 is not null and (_col1 = 2000)) - PTF Operator [PTF_313] (rows=1810380 width=601) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST, _col2 ASC NULLS LAST","partition by:":"_col6, _col5, _col3, _col4"}] - Select Operator [SEL_312] (rows=1810380 width=601) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_311] - PartitionCols:_col5, _col4, _col2, _col3 - Select Operator [SEL_310] (rows=1810380 width=489) - Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_309] (rows=1810380 width=489) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col5 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col2 ASC NULLS FIRST, _col3 ASC NULLS FIRST, _col0 ASC NULLS FIRST","partition by:":"_col5, _col4, _col2, _col3, _col0"}] - Select Operator [SEL_308] (rows=1810380 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_298] - PartitionCols:_col5, _col4, _col2, _col3, _col0 - Please refer to the previous Group By Operator [GBY_296] + Top N Key Operator [TNK_178] (rows=301730 width=546) + keys:(_col12 - _col13), _col11,top n:100 + Merge Join Operator [MERGEJOIN_279] (rows=301730 width=546) + Conds:RS_106._col6, _col7, _col8, _col9, _col14=RS_307._col0, _col1, _col2, _col3, _col5(Inner),Output:["_col4","_col6","_col10","_col11","_col12","_col13","_col19"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_307] + PartitionCols:_col0, _col1, _col2, _col3, _col5 + Select Operator [SEL_305] (rows=1810380 width=485) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_303] (rows=1810380 width=489) + predicate:rank_window_0 is not null + PTF Operator [PTF_301] (rows=1810380 width=489) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col5, _col4, _col2, _col3"}] + Select Operator [SEL_300] (rows=1810380 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_298] + PartitionCols:_col5, _col4, _col2, _col3 + Group By Operator [GBY_297] (rows=1810380 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_93] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_92] (rows=525329897 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col8, _col9, _col11, _col12 + Merge Join Operator [MERGEJOIN_277] (rows=525329897 width=483) + Conds:RS_88._col1=RS_296._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col11","_col12"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_296] + PartitionCols:_col0 + Select Operator [SEL_295] (rows=462000 width=194) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_294] (rows=462000 width=194) + predicate:(i_category is not null and i_brand is not null) + TableScan [TS_79] (rows=462000 width=194) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_276] (rows=525329897 width=297) + Conds:RS_85._col2=RS_293._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col8","_col9"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_293] + PartitionCols:_col0 + Select Operator [SEL_292] (rows=1704 width=183) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_291] (rows=1704 width=183) + predicate:(s_store_name is not null and s_company_name is not null) + TableScan [TS_76] (rows=1704 width=183) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_275] (rows=525329897 width=122) + Conds:RS_290._col0=RS_282._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_282] + PartitionCols:_col0 + Select Operator [SEL_281] (rows=564 width=12) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_280] (rows=564 width=12) + predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1)))) + TableScan [TS_73] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_290] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_288] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_70] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_287] + Group By Operator [GBY_286] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_285] + Group By Operator [GBY_284] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_283] (rows=564 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_281] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_106] + PartitionCols:_col6, _col7, _col8, _col9, _col14 + Merge Join Operator [MERGEJOIN_278] (rows=301730 width=717) + Conds:RS_308._col0, _col1, _col2, _col3, _col5=RS_319._col0, _col1, _col2, _col3, _col8(Inner),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_308] + PartitionCols:_col0, _col1, _col2, _col3, _col5 + Select Operator [SEL_306] (rows=1810380 width=485) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_304] (rows=1810380 width=489) + predicate:rank_window_0 is not null + PTF Operator [PTF_302] (rows=1810380 width=489) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col5, _col4, _col2, _col3"}] + Please refer to the previous Select Operator [SEL_300] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_319] + PartitionCols:_col0, _col1, _col2, _col3, _col8 + Select Operator [SEL_318] (rows=301730 width=605) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_317] (rows=301730 width=605) + predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col7 - _col0)) / _col0) > 0.1)) ELSE (false) END + Select Operator [SEL_316] (rows=603460 width=601) + Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_315] (rows=603460 width=601) + predicate:((_col0 > 0) and rank_window_1 is not null and (_col1 = 2000)) + PTF Operator [PTF_314] (rows=1810380 width=601) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST, _col2 ASC NULLS LAST","partition by:":"_col6, _col5, _col3, _col4"}] + Select Operator [SEL_313] (rows=1810380 width=601) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_312] + PartitionCols:_col5, _col4, _col2, _col3 + Select Operator [SEL_311] (rows=1810380 width=489) + Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + PTF Operator [PTF_310] (rows=1810380 width=489) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col5 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col2 ASC NULLS FIRST, _col3 ASC NULLS FIRST, _col0 ASC NULLS FIRST","partition by:":"_col5, _col4, _col2, _col3, _col0"}] + Select Operator [SEL_309] (rows=1810380 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_299] + PartitionCols:_col5, _col4, _col2, _col3, _col0 + Please refer to the previous Group By Operator [GBY_297] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query49.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query49.q.out index b384aea779..37fc51697b 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query49.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query49.q.out @@ -299,46 +299,46 @@ Stage-0 limit:100 Stage-1 Reducer 11 vectorized - File Output Operator [FS_310] - Limit [LIM_309] (rows=100 width=215) + File Output Operator [FS_315] + Limit [LIM_314] (rows=100 width=215) Number of rows:100 - Select Operator [SEL_308] (rows=40436 width=215) + Select Operator [SEL_313] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_307] - Select Operator [SEL_306] (rows=40436 width=215) + SHUFFLE [RS_312] + Select Operator [SEL_311] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_305] (rows=40436 width=215) + Group By Operator [GBY_310] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 9 [SIMPLE_EDGE] <-Reducer 24 [CONTAINS] vectorized - Reduce Output Operator [RS_351] + Reduce Output Operator [RS_356] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_350] (rows=40436 width=215) + Group By Operator [GBY_355] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Top N Key Operator [TNK_349] (rows=40436 width=214) + Top N Key Operator [TNK_354] (rows=40436 width=214) keys:_col0, _col3, _col4, _col1, _col2,top n:100 - Select Operator [SEL_348] (rows=14232 width=213) + Select Operator [SEL_353] (rows=14232 width=213) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_347] (rows=14232 width=248) + Filter Operator [FIL_352] (rows=14232 width=248) predicate:((_col0 <= 10) or (rank_window_1 <= 10)) - PTF Operator [PTF_346] (rows=21349 width=248) + PTF Operator [PTF_351] (rows=21349 width=248) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col4 AS decimal(15,4)) / CAST( _col5 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_345] (rows=21349 width=248) + Select Operator [SEL_350] (rows=21349 width=248) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] + SHUFFLE [RS_349] PartitionCols:0 - Select Operator [SEL_343] (rows=21349 width=244) + Select Operator [SEL_348] (rows=21349 width=244) Output:["rank_window_0","_col0","_col1","_col2","_col3","_col4"] - PTF Operator [PTF_342] (rows=21349 width=244) + PTF Operator [PTF_347] (rows=21349 width=244) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col1 AS decimal(15,4)) / CAST( _col2 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_341] (rows=21349 width=244) + Select Operator [SEL_346] (rows=21349 width=244) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_340] + SHUFFLE [RS_345] PartitionCols:0 - Group By Operator [GBY_339] (rows=21349 width=244) + Group By Operator [GBY_344] (rows=21349 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 21 [SIMPLE_EDGE] SHUFFLE [RS_89] @@ -347,89 +347,89 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0 Select Operator [SEL_86] (rows=20856667 width=216) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_237] (rows=20856667 width=216) - Conds:RS_83._col1, _col2=RS_338._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col9","_col10"] + Merge Join Operator [MERGEJOIN_242] (rows=20856667 width=216) + Conds:RS_83._col1, _col2=RS_343._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col9","_col10"] <-Map 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_338] + SHUFFLE [RS_343] PartitionCols:_col0, _col1 - Select Operator [SEL_337] (rows=19197050 width=119) + Select Operator [SEL_342] (rows=19197050 width=119) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_336] (rows=19197050 width=119) + Filter Operator [FIL_341] (rows=19197050 width=119) predicate:(sr_return_amt > 10000) TableScan [TS_77] (rows=57591150 width=119) default@store_returns,sr,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_quantity","sr_return_amt"] <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_83] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_236] (rows=61119617 width=118) - Conds:RS_335._col0=RS_272._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_241] (rows=61119617 width=118) + Conds:RS_340._col0=RS_277._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_272] + PARTITION_ONLY_SHUFFLE [RS_277] PartitionCols:_col0 - Select Operator [SEL_267] (rows=50 width=4) + Select Operator [SEL_272] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_266] (rows=50 width=12) + Filter Operator [FIL_271] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 12)) TableScan [TS_3] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_335] + SHUFFLE [RS_340] PartitionCols:_col0 - Select Operator [SEL_334] (rows=61119617 width=229) + Select Operator [SEL_339] (rows=61119617 width=229) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_333] (rows=61119617 width=229) + Filter Operator [FIL_338] (rows=61119617 width=229) predicate:((ss_net_profit > 1) and (ss_net_paid > 0) and (ss_quantity > 0) and ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_81_date_dim_d_date_sk_min) AND DynamicValue(RS_81_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_81_date_dim_d_date_sk_bloom_filter))) TableScan [TS_71] (rows=575995635 width=229) default@store_sales,sts,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_net_paid","ss_net_profit"] <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_332] - Group By Operator [GBY_331] (rows=1 width=12) + BROADCAST [RS_337] + Group By Operator [GBY_336] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_279] - Group By Operator [GBY_276] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_284] + Group By Operator [GBY_281] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_273] (rows=50 width=4) + Select Operator [SEL_278] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_267] + Please refer to the previous Select Operator [SEL_272] <-Reducer 8 [CONTAINS] vectorized - Reduce Output Operator [RS_304] + Reduce Output Operator [RS_309] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_303] (rows=40436 width=215) + Group By Operator [GBY_308] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Top N Key Operator [TNK_302] (rows=40436 width=214) + Top N Key Operator [TNK_307] (rows=40436 width=214) keys:_col0, _col3, _col4, _col1, _col2,top n:100 - Select Operator [SEL_301] (rows=26204 width=215) + Select Operator [SEL_306] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_300] (rows=26204 width=215) + Group By Operator [GBY_305] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 7 [SIMPLE_EDGE] <-Reducer 18 [CONTAINS] vectorized - Reduce Output Operator [RS_330] + Reduce Output Operator [RS_335] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_329] (rows=26204 width=215) + Group By Operator [GBY_334] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Select Operator [SEL_328] (rows=12574 width=215) + Select Operator [SEL_333] (rows=12574 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_327] (rows=12574 width=248) + Filter Operator [FIL_332] (rows=12574 width=248) predicate:((_col0 <= 10) or (rank_window_1 <= 10)) - PTF Operator [PTF_326] (rows=18863 width=248) + PTF Operator [PTF_331] (rows=18863 width=248) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col4 AS decimal(15,4)) / CAST( _col5 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_325] (rows=18863 width=248) + Select Operator [SEL_330] (rows=18863 width=248) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_324] + SHUFFLE [RS_329] PartitionCols:0 - Select Operator [SEL_323] (rows=18863 width=244) + Select Operator [SEL_328] (rows=18863 width=244) Output:["rank_window_0","_col0","_col1","_col2","_col3","_col4"] - PTF Operator [PTF_322] (rows=18863 width=244) + PTF Operator [PTF_327] (rows=18863 width=244) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col1 AS decimal(15,4)) / CAST( _col2 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_321] (rows=18863 width=244) + Select Operator [SEL_326] (rows=18863 width=244) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_320] + SHUFFLE [RS_325] PartitionCols:0 - Group By Operator [GBY_319] (rows=18863 width=244) + Group By Operator [GBY_324] (rows=18863 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_50] @@ -438,72 +438,72 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0 Select Operator [SEL_47] (rows=9599627 width=231) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_235] (rows=9599627 width=231) - Conds:RS_44._col1, _col2=RS_318._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col9","_col10"] + Merge Join Operator [MERGEJOIN_240] (rows=9599627 width=231) + Conds:RS_44._col1, _col2=RS_323._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col9","_col10"] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] + SHUFFLE [RS_323] PartitionCols:_col0, _col1 - Select Operator [SEL_317] (rows=9599627 width=121) + Select Operator [SEL_322] (rows=9599627 width=121) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_316] (rows=9599627 width=121) + Filter Operator [FIL_321] (rows=9599627 width=121) predicate:(cr_return_amount > 10000) TableScan [TS_38] (rows=28798881 width=121) default@catalog_returns,cr,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_quantity","cr_return_amount"] <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_234] (rows=31838858 width=123) - Conds:RS_315._col0=RS_270._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_239] (rows=31838858 width=123) + Conds:RS_320._col0=RS_275._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_270] + PARTITION_ONLY_SHUFFLE [RS_275] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_267] + Please refer to the previous Select Operator [SEL_272] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_315] + SHUFFLE [RS_320] PartitionCols:_col0 - Select Operator [SEL_314] (rows=31838858 width=239) + Select Operator [SEL_319] (rows=31838858 width=239) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_313] (rows=31838858 width=239) + Filter Operator [FIL_318] (rows=31838858 width=239) predicate:((cs_net_profit > 1) and (cs_net_paid > 0) and (cs_quantity > 0) and cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_42_date_dim_d_date_sk_min) AND DynamicValue(RS_42_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_42_date_dim_d_date_sk_bloom_filter))) TableScan [TS_32] (rows=287989836 width=239) default@catalog_sales,cs,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_net_paid","cs_net_profit"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_312] - Group By Operator [GBY_311] (rows=1 width=12) + BROADCAST [RS_317] + Group By Operator [GBY_316] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_278] - Group By Operator [GBY_275] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_283] + Group By Operator [GBY_280] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_271] (rows=50 width=4) + Select Operator [SEL_276] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_267] + Please refer to the previous Select Operator [SEL_272] <-Reducer 6 [CONTAINS] vectorized - Reduce Output Operator [RS_299] + Reduce Output Operator [RS_304] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_298] (rows=26204 width=215) + Group By Operator [GBY_303] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Select Operator [SEL_297] (rows=13630 width=211) + Select Operator [SEL_302] (rows=13630 width=211) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_296] (rows=13630 width=248) + Filter Operator [FIL_301] (rows=13630 width=248) predicate:((_col0 <= 10) or (rank_window_1 <= 10)) - PTF Operator [PTF_295] (rows=20445 width=248) + PTF Operator [PTF_300] (rows=20445 width=248) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col4 AS decimal(15,4)) / CAST( _col5 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_294] (rows=20445 width=248) + Select Operator [SEL_299] (rows=20445 width=248) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_293] + SHUFFLE [RS_298] PartitionCols:0 - Select Operator [SEL_292] (rows=20445 width=244) + Select Operator [SEL_297] (rows=20445 width=244) Output:["rank_window_0","_col0","_col1","_col2","_col3","_col4"] - PTF Operator [PTF_291] (rows=20445 width=244) + PTF Operator [PTF_296] (rows=20445 width=244) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col1 AS decimal(15,4)) / CAST( _col2 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_290] (rows=20445 width=244) + Select Operator [SEL_295] (rows=20445 width=244) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_289] + SHUFFLE [RS_294] PartitionCols:0 - Group By Operator [GBY_288] (rows=20445 width=244) + Group By Operator [GBY_293] (rows=20445 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_18] @@ -512,44 +512,44 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0 Select Operator [SEL_15] (rows=5227456 width=231) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_233] (rows=5227456 width=231) - Conds:RS_12._col1, _col2=RS_287._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col9","_col10"] + Merge Join Operator [MERGEJOIN_238] (rows=5227456 width=231) + Conds:RS_12._col1, _col2=RS_292._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_287] + SHUFFLE [RS_292] PartitionCols:_col0, _col1 - Select Operator [SEL_286] (rows=4799489 width=118) + Select Operator [SEL_291] (rows=4799489 width=118) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_285] (rows=4799489 width=118) + Filter Operator [FIL_290] (rows=4799489 width=118) predicate:(wr_return_amt > 10000) TableScan [TS_6] (rows=14398467 width=118) default@web_returns,wr,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_quantity","wr_return_amt"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_232] (rows=15996318 width=123) - Conds:RS_284._col0=RS_268._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_237] (rows=15996318 width=123) + Conds:RS_289._col0=RS_273._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_268] + PARTITION_ONLY_SHUFFLE [RS_273] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_267] + Please refer to the previous Select Operator [SEL_272] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] + SHUFFLE [RS_289] PartitionCols:_col0 - Select Operator [SEL_283] (rows=15996318 width=239) + Select Operator [SEL_288] (rows=15996318 width=239) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_282] (rows=15996318 width=239) + Filter Operator [FIL_287] (rows=15996318 width=239) predicate:((ws_net_profit > 1) and (ws_net_paid > 0) and (ws_quantity > 0) and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=144002668 width=239) default@web_sales,ws,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_net_paid","ws_net_profit"] <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_281] - Group By Operator [GBY_280] (rows=1 width=12) + BROADCAST [RS_286] + Group By Operator [GBY_285] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_277] - Group By Operator [GBY_274] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_282] + Group By Operator [GBY_279] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_269] (rows=50 width=4) + Select Operator [SEL_274] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_267] + Please refer to the previous Select Operator [SEL_272] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query5.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query5.q.out index d3f79820f2..13288d28b4 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query5.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query5.q.out @@ -303,229 +303,229 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_300] - Limit [LIM_299] (rows=100 width=619) + File Output Operator [FS_302] + Limit [LIM_301] (rows=100 width=619) Number of rows:100 - Select Operator [SEL_298] (rows=59581 width=619) + Select Operator [SEL_300] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_297] - Select Operator [SEL_296] (rows=59581 width=619) + SHUFFLE [RS_299] + Select Operator [SEL_298] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_295] (rows=59581 width=627) + Group By Operator [GBY_297] (rows=59581 width=627) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 6 [SIMPLE_EDGE] <-Reducer 14 [CONTAINS] vectorized - Reduce Output Operator [RS_310] + Reduce Output Operator [RS_312] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_309] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_308] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_307] (rows=38846 width=619) + Top N Key Operator [TNK_311] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_310] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_309] (rows=38846 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_306] (rows=38846 width=548) + Group By Operator [GBY_308] (rows=38846 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_45] PartitionCols:_col0 Group By Operator [GBY_44] (rows=26026820 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col8 - Merge Join Operator [MERGEJOIN_219] (rows=313339499 width=546) - Conds:RS_40._col0=RS_305._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] + Merge Join Operator [MERGEJOIN_221] (rows=313339499 width=546) + Conds:RS_40._col0=RS_307._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_305] + SHUFFLE [RS_307] PartitionCols:_col0 - Select Operator [SEL_304] (rows=46000 width=104) + Select Operator [SEL_306] (rows=46000 width=104) Output:["_col0","_col1"] TableScan [TS_35] (rows=46000 width=104) default@catalog_page,catalog_page,Tbl:COMPLETE,Col:COMPLETE,Output:["cp_catalog_page_sk","cp_catalog_page_id"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_40] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_218] (rows=313339499 width=450) - Conds:Union 22._col1=RS_273._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_220] (rows=313339499 width=450) + Conds:Union 22._col1=RS_275._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_273] + SHUFFLE [RS_275] PartitionCols:_col0 - Select Operator [SEL_270] (rows=8116 width=4) + Select Operator [SEL_272] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_269] (rows=8116 width=98) + Filter Operator [FIL_271] (rows=8116 width=98) predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-08-04 00:00:00' AND TIMESTAMP'1998-08-18 00:00:00' TableScan [TS_8] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Union 22 [SIMPLE_EDGE] <-Map 21 [CONTAINS] vectorized - Reduce Output Operator [RS_322] + Reduce Output Operator [RS_324] PartitionCols:_col1 - Select Operator [SEL_321] (rows=285117694 width=455) + Select Operator [SEL_323] (rows=285117694 width=455) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_320] (rows=285117694 width=231) + Filter Operator [FIL_322] (rows=285117694 width=231) predicate:(cs_sold_date_sk is not null and cs_catalog_page_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_38_date_dim_d_date_sk_min) AND DynamicValue(RS_38_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_38_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_250] (rows=287989836 width=231) + TableScan [TS_252] (rows=287989836 width=231) Output:["cs_sold_date_sk","cs_catalog_page_sk","cs_ext_sales_price","cs_net_profit"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_319] - Group By Operator [GBY_318] (rows=1 width=12) + BROADCAST [RS_321] + Group By Operator [GBY_320] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] - Group By Operator [GBY_278] (rows=1 width=12) + SHUFFLE [RS_283] + Group By Operator [GBY_280] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_274] (rows=8116 width=4) + Select Operator [SEL_276] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_270] + Please refer to the previous Select Operator [SEL_272] <-Map 23 [CONTAINS] vectorized - Reduce Output Operator [RS_325] + Reduce Output Operator [RS_327] PartitionCols:_col1 - Select Operator [SEL_324] (rows=28221805 width=451) + Select Operator [SEL_326] (rows=28221805 width=451) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_323] (rows=28221805 width=227) + Filter Operator [FIL_325] (rows=28221805 width=227) predicate:(cr_catalog_page_sk is not null and cr_returned_date_sk is not null) - TableScan [TS_255] (rows=28798881 width=227) + TableScan [TS_257] (rows=28798881 width=227) Output:["cr_returned_date_sk","cr_catalog_page_sk","cr_return_amount","cr_net_loss"] <-Reducer 18 [CONTAINS] vectorized - Reduce Output Operator [RS_317] + Reduce Output Operator [RS_319] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_316] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_315] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_314] (rows=53 width=615) + Top N Key Operator [TNK_318] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_317] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_316] (rows=53 width=615) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_313] (rows=53 width=548) + Group By Operator [GBY_315] (rows=53 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 17 [SIMPLE_EDGE] SHUFFLE [RS_77] PartitionCols:_col0 Group By Operator [GBY_76] (rows=31641 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col8 - Merge Join Operator [MERGEJOIN_221] (rows=278713608 width=547) - Conds:RS_72._col0=RS_312._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] + Merge Join Operator [MERGEJOIN_223] (rows=278713608 width=547) + Conds:RS_72._col0=RS_314._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] <-Map 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_312] + SHUFFLE [RS_314] PartitionCols:_col0 - Select Operator [SEL_311] (rows=84 width=104) + Select Operator [SEL_313] (rows=84 width=104) Output:["_col0","_col1"] TableScan [TS_67] (rows=84 width=104) default@web_site,web_site,Tbl:COMPLETE,Col:COMPLETE,Output:["web_site_sk","web_site_id"] <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_72] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_220] (rows=278713608 width=451) - Conds:Union 26._col1=RS_275._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_222] (rows=278713608 width=451) + Conds:Union 26._col1=RS_277._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_275] + SHUFFLE [RS_277] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_270] + Please refer to the previous Select Operator [SEL_272] <-Union 26 [SIMPLE_EDGE] <-Map 25 [CONTAINS] vectorized - Reduce Output Operator [RS_330] + Reduce Output Operator [RS_332] PartitionCols:_col1 - Select Operator [SEL_329] (rows=143930874 width=455) + Select Operator [SEL_331] (rows=143930874 width=455) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_328] (rows=143930874 width=231) + Filter Operator [FIL_330] (rows=143930874 width=231) predicate:(ws_web_site_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_70_date_dim_d_date_sk_min) AND DynamicValue(RS_70_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_70_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_260] (rows=144002668 width=231) + TableScan [TS_262] (rows=144002668 width=231) Output:["ws_sold_date_sk","ws_web_site_sk","ws_ext_sales_price","ws_net_profit"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_327] - Group By Operator [GBY_326] (rows=1 width=12) + BROADCAST [RS_329] + Group By Operator [GBY_328] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_282] - Group By Operator [GBY_279] (rows=1 width=12) + SHUFFLE [RS_284] + Group By Operator [GBY_281] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_276] (rows=8116 width=4) + Select Operator [SEL_278] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_270] + Please refer to the previous Select Operator [SEL_272] <-Reducer 28 [CONTAINS] - Reduce Output Operator [RS_268] + Reduce Output Operator [RS_270] PartitionCols:_col1 - Select Operator [SEL_266] (rows=134782734 width=454) + Select Operator [SEL_268] (rows=134782734 width=454) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_265] (rows=134782734 width=230) - Conds:RS_333._col0, _col2=RS_336._col1, _col2(Inner),Output:["_col1","_col3","_col6","_col7"] + Merge Join Operator [MERGEJOIN_267] (rows=134782734 width=230) + Conds:RS_335._col0, _col2=RS_338._col1, _col2(Inner),Output:["_col1","_col3","_col6","_col7"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_333] + SHUFFLE [RS_335] PartitionCols:_col0, _col2 - Select Operator [SEL_332] (rows=143966669 width=11) + Select Operator [SEL_334] (rows=143966669 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_331] (rows=143966669 width=11) + Filter Operator [FIL_333] (rows=143966669 width=11) predicate:ws_web_site_sk is not null TableScan [TS_52] (rows=144002668 width=11) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_item_sk","ws_web_site_sk","ws_order_number"] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_336] + SHUFFLE [RS_338] PartitionCols:_col1, _col2 - Select Operator [SEL_335] (rows=13749816 width=225) + Select Operator [SEL_337] (rows=13749816 width=225) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_334] (rows=13749816 width=225) + Filter Operator [FIL_336] (rows=13749816 width=225) predicate:wr_returned_date_sk is not null TableScan [TS_55] (rows=14398467 width=225) default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_item_sk","wr_order_number","wr_return_amt","wr_net_loss"] <-Reducer 5 [CONTAINS] vectorized - Reduce Output Operator [RS_294] + Reduce Output Operator [RS_296] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_293] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_292] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_291] (rows=822 width=617) + Top N Key Operator [TNK_295] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_294] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_293] (rows=822 width=617) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_290] (rows=822 width=548) + Group By Operator [GBY_292] (rows=822 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col0 Group By Operator [GBY_20] (rows=983934 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col8 - Merge Join Operator [MERGEJOIN_217] (rows=578964757 width=528) - Conds:RS_16._col0=RS_289._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] + Merge Join Operator [MERGEJOIN_219] (rows=578964757 width=528) + Conds:RS_16._col0=RS_291._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_289] + SHUFFLE [RS_291] PartitionCols:_col0 - Select Operator [SEL_288] (rows=1704 width=104) + Select Operator [SEL_290] (rows=1704 width=104) Output:["_col0","_col1"] TableScan [TS_11] (rows=1704 width=104) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_16] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_216] (rows=578964757 width=432) - Conds:Union 2._col1=RS_271._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_218] (rows=578964757 width=432) + Conds:Union 2._col1=RS_273._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_271] + SHUFFLE [RS_273] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_270] + Please refer to the previous Select Operator [SEL_272] <-Union 2 [SIMPLE_EDGE] <-Map 1 [CONTAINS] vectorized - Reduce Output Operator [RS_287] + Reduce Output Operator [RS_289] PartitionCols:_col1 - Select Operator [SEL_286] (rows=525329897 width=445) + Select Operator [SEL_288] (rows=525329897 width=445) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_285] (rows=525329897 width=221) + Filter Operator [FIL_287] (rows=525329897 width=221) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_14_date_dim_d_date_sk_min) AND DynamicValue(RS_14_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_14_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_222] (rows=575995635 width=221) + TableScan [TS_224] (rows=575995635 width=221) Output:["ss_sold_date_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_284] - Group By Operator [GBY_283] (rows=1 width=12) + BROADCAST [RS_286] + Group By Operator [GBY_285] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_280] - Group By Operator [GBY_277] (rows=1 width=12) + SHUFFLE [RS_282] + Group By Operator [GBY_279] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_272] (rows=8116 width=4) + Select Operator [SEL_274] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_270] + Please refer to the previous Select Operator [SEL_272] <-Map 9 [CONTAINS] vectorized - Reduce Output Operator [RS_303] + Reduce Output Operator [RS_305] PartitionCols:_col1 - Select Operator [SEL_302] (rows=53634860 width=447) + Select Operator [SEL_304] (rows=53634860 width=447) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_301] (rows=53634860 width=223) + Filter Operator [FIL_303] (rows=53634860 width=223) predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) - TableScan [TS_233] (rows=57591150 width=223) + TableScan [TS_235] (rows=57591150 width=223) Output:["sr_returned_date_sk","sr_store_sk","sr_return_amt","sr_net_loss"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query50.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query50.q.out index 8c9754967f..db09f6b0cd 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query50.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query50.q.out @@ -138,67 +138,67 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_112] - Limit [LIM_111] (rows=100 width=858) + File Output Operator [FS_117] + Limit [LIM_116] (rows=100 width=858) Number of rows:100 - Select Operator [SEL_110] (rows=478292911 width=857) + Select Operator [SEL_115] (rows=478292911 width=857) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_109] - Group By Operator [GBY_108] (rows=478292911 width=857) + SHUFFLE [RS_114] + Group By Operator [GBY_113] (rows=478292911 width=857) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, KEY._col8, KEY._col9 <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 Group By Operator [GBY_22] (rows=478292911 width=857) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 - Top N Key Operator [TNK_43] (rows=478292911 width=825) - keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9,top n:100 - Select Operator [SEL_20] (rows=478292911 width=825) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] - Merge Join Operator [MERGEJOIN_96] (rows=478292911 width=825) - Conds:RS_17._col8=RS_107._col0(Inner),Output:["_col0","_col5","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20"] + Select Operator [SEL_20] (rows=478292911 width=825) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] + Top N Key Operator [TNK_46] (rows=478292911 width=825) + keys:_col11, _col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20,top n:100 + Merge Join Operator [MERGEJOIN_101] (rows=478292911 width=825) + Conds:RS_17._col8=RS_112._col0(Inner),Output:["_col0","_col5","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_107] + SHUFFLE [RS_112] PartitionCols:_col0 - Select Operator [SEL_106] (rows=1704 width=821) + Select Operator [SEL_111] (rows=1704 width=821) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] TableScan [TS_9] (rows=1704 width=821) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_id","s_street_number","s_street_name","s_street_type","s_suite_number","s_city","s_county","s_state","s_zip"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col8 - Merge Join Operator [MERGEJOIN_95] (rows=478292911 width=11) - Conds:RS_14._col1, _col2, _col3=RS_105._col1, _col2, _col4(Inner),Output:["_col0","_col5","_col8"] + Merge Join Operator [MERGEJOIN_100] (rows=478292911 width=11) + Conds:RS_14._col1, _col2, _col3=RS_110._col1, _col2, _col4(Inner),Output:["_col0","_col5","_col8"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_105] + SHUFFLE [RS_110] PartitionCols:_col1, _col2, _col4 - Select Operator [SEL_104] (rows=501694138 width=19) + Select Operator [SEL_109] (rows=501694138 width=19) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_103] (rows=501694138 width=19) + Filter Operator [FIL_108] (rows=501694138 width=19) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null) TableScan [TS_6] (rows=575995635 width=19) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_14] PartitionCols:_col1, _col2, _col3 - Merge Join Operator [MERGEJOIN_94] (rows=53632139 width=15) - Conds:RS_99._col0=RS_102._col0(Inner),Output:["_col0","_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_99] (rows=53632139 width=15) + Conds:RS_104._col0=RS_107._col0(Inner),Output:["_col0","_col1","_col2","_col3"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_99] + SHUFFLE [RS_104] PartitionCols:_col0 - Select Operator [SEL_98] (rows=53632139 width=15) + Select Operator [SEL_103] (rows=53632139 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_97] (rows=53632139 width=15) + Filter Operator [FIL_102] (rows=53632139 width=15) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null) TableScan [TS_0] (rows=57591150 width=15) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number"] <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_102] + SHUFFLE [RS_107] PartitionCols:_col0 - Select Operator [SEL_101] (rows=50 width=4) + Select Operator [SEL_106] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_100] (rows=50 width=12) + Filter Operator [FIL_105] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 9)) TableScan [TS_3] (rows=73049 width=12) default@date_dim,d2,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query51.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query51.q.out index 4255d5cc33..2ceca679e5 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query51.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query51.q.out @@ -114,109 +114,111 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_117] - Limit [LIM_116] (rows=100 width=636) + File Output Operator [FS_119] + Limit [LIM_118] (rows=100 width=636) Number of rows:100 - Select Operator [SEL_115] (rows=2095597606 width=636) + Select Operator [SEL_117] (rows=2095597606 width=636) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_114] - Select Operator [SEL_113] (rows=2095597606 width=636) + SHUFFLE [RS_116] + Select Operator [SEL_115] (rows=2095597606 width=636) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_112] (rows=2095597606 width=420) - predicate:(max_window_0 > max_window_1) - PTF Operator [PTF_111] (rows=6286792818 width=420) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"CASE WHEN (_col4 is not null) THEN (_col4) ELSE (_col1) END ASC NULLS LAST","partition by:":"CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END"}] - Select Operator [SEL_110] (rows=6286792818 width=420) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_43] - PartitionCols:CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END - Merge Join Operator [MERGEJOIN_87] (rows=6286792818 width=420) - Conds:RS_40._col0, _col1=RS_41._col0, _col1(Outer),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_41] - PartitionCols:_col0, _col1 - Select Operator [SEL_37] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"] - PTF Operator [PTF_36] (rows=19832154 width=210) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] - Group By Operator [GBY_32] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col0 - Group By Operator [GBY_30] (rows=143966864 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 - Merge Join Operator [MERGEJOIN_86] (rows=143966864 width=209) - Conds:RS_108._col0=RS_92._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] - PartitionCols:_col0 - Select Operator [SEL_89] (rows=317 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_88] (rows=317 width=102) - predicate:d_month_seq BETWEEN 1212 AND 1223 - TableScan [TS_3] (rows=73049 width=102) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_month_seq"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_108] - PartitionCols:_col0 - Select Operator [SEL_107] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_106] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_27_date_dim_d_date_sk_min) AND DynamicValue(RS_27_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_27_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_sales_price"] - <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_105] - Group By Operator [GBY_104] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - Group By Operator [GBY_95] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_93] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_89] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col0, _col1 - Select Operator [SEL_17] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"] - PTF Operator [PTF_16] (rows=19832154 width=210) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] - Group By Operator [GBY_12] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col0 - Group By Operator [GBY_10] (rows=550076554 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 - Merge Join Operator [MERGEJOIN_85] (rows=550076554 width=204) - Conds:RS_102._col0=RS_90._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_90] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_89] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_102] - PartitionCols:_col0 - Select Operator [SEL_101] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_100] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_99] - Group By Operator [GBY_98] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] - Group By Operator [GBY_94] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_91] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_89] + Top N Key Operator [TNK_114] (rows=2095597606 width=420) + keys:CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END, CASE WHEN (_col4 is not null) THEN (_col4) ELSE (_col1) END,top n:100 + Filter Operator [FIL_113] (rows=2095597606 width=420) + predicate:(max_window_0 > max_window_1) + PTF Operator [PTF_112] (rows=6286792818 width=420) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"CASE WHEN (_col4 is not null) THEN (_col4) ELSE (_col1) END ASC NULLS LAST","partition by:":"CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END"}] + Select Operator [SEL_111] (rows=6286792818 width=420) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END + Merge Join Operator [MERGEJOIN_88] (rows=6286792818 width=420) + Conds:RS_40._col0, _col1=RS_41._col0, _col1(Outer),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_41] + PartitionCols:_col0, _col1 + Select Operator [SEL_37] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"] + PTF Operator [PTF_36] (rows=19832154 width=210) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] + Group By Operator [GBY_32] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col0 + Group By Operator [GBY_30] (rows=143966864 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 + Merge Join Operator [MERGEJOIN_87] (rows=143966864 width=209) + Conds:RS_109._col0=RS_93._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_93] + PartitionCols:_col0 + Select Operator [SEL_90] (rows=317 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_89] (rows=317 width=102) + predicate:d_month_seq BETWEEN 1212 AND 1223 + TableScan [TS_3] (rows=73049 width=102) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_month_seq"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_109] + PartitionCols:_col0 + Select Operator [SEL_108] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_107] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_27_date_dim_d_date_sk_min) AND DynamicValue(RS_27_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_27_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_sales_price"] + <-Reducer 11 [BROADCAST_EDGE] vectorized + BROADCAST [RS_106] + Group By Operator [GBY_105] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_98] + Group By Operator [GBY_96] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_94] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_90] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col0, _col1 + Select Operator [SEL_17] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"] + PTF Operator [PTF_16] (rows=19832154 width=210) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] + Group By Operator [GBY_12] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col0 + Group By Operator [GBY_10] (rows=550076554 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 + Merge Join Operator [MERGEJOIN_86] (rows=550076554 width=204) + Conds:RS_103._col0=RS_91._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_91] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_90] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_103] + PartitionCols:_col0 + Select Operator [SEL_102] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_101] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_100] + Group By Operator [GBY_99] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_97] + Group By Operator [GBY_95] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_92] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_90] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query52.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query52.q.out index 56d73b8d46..2c09c7bfe6 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query52.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query52.q.out @@ -63,65 +63,67 @@ Stage-0 limit:-1 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Select Operator [SEL_73] (rows=100 width=220) + File Output Operator [FS_76] + Select Operator [SEL_75] (rows=100 width=220) Output:["_col0","_col1","_col2","_col3"] - Limit [LIM_72] (rows=100 width=216) + Limit [LIM_74] (rows=100 width=216) Number of rows:100 - Select Operator [SEL_71] (rows=7333 width=216) + Select Operator [SEL_73] (rows=7333 width=216) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_70] - Group By Operator [GBY_69] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1 - Group By Operator [GBY_16] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 - Merge Join Operator [MERGEJOIN_54] (rows=84037218 width=183) - Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_68] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=7333 width=107) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_66] (rows=7333 width=111) - predicate:(i_manager_id = 1) - TableScan [TS_6] (rows=462000 width=111) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_53] (rows=550076554 width=110) - Conds:RS_65._col0=RS_57._col0(Inner),Output:["_col1","_col2"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_57] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_55] (rows=50 width=12) - predicate:((d_year = 1998) and (d_moy = 12)) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_63] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_62] - Group By Operator [GBY_61] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_60] - Group By Operator [GBY_59] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_58] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_56] + SHUFFLE [RS_72] + Top N Key Operator [TNK_71] (rows=7333 width=216) + keys:_col2, _col0,top n:100 + Group By Operator [GBY_70] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1 + Group By Operator [GBY_16] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 + Merge Join Operator [MERGEJOIN_55] (rows=84037218 width=183) + Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] + PartitionCols:_col0 + Select Operator [SEL_68] (rows=7333 width=107) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_67] (rows=7333 width=111) + predicate:(i_manager_id = 1) + TableScan [TS_6] (rows=462000 width=111) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_54] (rows=550076554 width=110) + Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_56] (rows=50 width=12) + predicate:((d_year = 1998) and (d_moy = 12)) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query53.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query53.q.out index f8f495d3a8..a5127334ec 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query53.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query53.q.out @@ -77,73 +77,75 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_81] - Limit [LIM_80] (rows=100 width=228) + File Output Operator [FS_82] + Limit [LIM_81] (rows=100 width=228) Number of rows:100 - Select Operator [SEL_79] (rows=130 width=228) + Select Operator [SEL_80] (rows=130 width=228) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_27] Select Operator [SEL_24] (rows=130 width=228) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_36] (rows=130 width=228) - predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END - Select Operator [SEL_23] (rows=260 width=116) - Output:["avg_window_0","_col0","_col2"] - PTF Operator [PTF_22] (rows=260 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] - Select Operator [SEL_19] (rows=260 width=116) - Output:["_col0","_col2"] - Group By Operator [GBY_18] (rows=260 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0 - Group By Operator [GBY_16] (rows=260 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col4, _col6 - Merge Join Operator [MERGEJOIN_62] (rows=569118 width=8) - Conds:RS_12._col0=RS_76._col0(Inner),Output:["_col2","_col4","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_76] - PartitionCols:_col0 - Select Operator [SEL_75] (rows=317 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_74] (rows=317 width=12) - predicate:(d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_qoy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_61] (rows=569118 width=4) - Conds:RS_73._col1=RS_65._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=52 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_63] (rows=52 width=290) - predicate:((i_class) IN ('personal', 'portable', 'reference', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'reference', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1')))) - TableScan [TS_3] (rows=462000 width=289) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manufact_id"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_73] - PartitionCols:_col1 - Select Operator [SEL_72] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_71] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_70] - Group By Operator [GBY_69] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_68] - Group By Operator [GBY_67] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_66] (rows=52 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_64] + Top N Key Operator [TNK_41] (rows=130 width=228) + keys:avg_window_0, _col2, _col0,top n:100 + Filter Operator [FIL_36] (rows=130 width=228) + predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END + Select Operator [SEL_23] (rows=260 width=116) + Output:["avg_window_0","_col0","_col2"] + PTF Operator [PTF_22] (rows=260 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] + Select Operator [SEL_19] (rows=260 width=116) + Output:["_col0","_col2"] + Group By Operator [GBY_18] (rows=260 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0 + Group By Operator [GBY_16] (rows=260 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col4, _col6 + Merge Join Operator [MERGEJOIN_63] (rows=569118 width=8) + Conds:RS_12._col0=RS_77._col0(Inner),Output:["_col2","_col4","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_77] + PartitionCols:_col0 + Select Operator [SEL_76] (rows=317 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_75] (rows=317 width=12) + predicate:(d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_qoy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_62] (rows=569118 width=4) + Conds:RS_74._col1=RS_66._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=52 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_64] (rows=52 width=290) + predicate:((i_class) IN ('personal', 'portable', 'reference', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'reference', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1')))) + TableScan [TS_3] (rows=462000 width=289) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manufact_id"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_74] + PartitionCols:_col1 + Select Operator [SEL_73] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_72] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_71] + Group By Operator [GBY_70] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_69] + Group By Operator [GBY_68] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_67] (rows=52 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_65] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out index d85597af02..c69ee7c2c3 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query54.q.out @@ -1,7 +1,7 @@ -Warning: Shuffle Join MERGEJOIN[275][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product -Warning: Shuffle Join MERGEJOIN[281][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product -Warning: Shuffle Join MERGEJOIN[280][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 15' is a cross product -Warning: Shuffle Join MERGEJOIN[283][tables = [$hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[277][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 2' is a cross product +Warning: Shuffle Join MERGEJOIN[283][tables = [$hdt$_0, $hdt$_1, $hdt$_2]] in Stage 'Reducer 3' is a cross product +Warning: Shuffle Join MERGEJOIN[282][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 15' is a cross product +Warning: Shuffle Join MERGEJOIN[285][tables = [$hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 16' is a cross product PREHOOK: query: explain with my_customers as ( select distinct c_customer_sk @@ -163,265 +163,269 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_367] - Limit [LIM_366] (rows=100 width=16) + File Output Operator [FS_371] + Limit [LIM_370] (rows=100 width=16) Number of rows:100 - Select Operator [SEL_365] (rows=338 width=16) + Select Operator [SEL_369] (rows=338 width=16) Output:["_col0","_col1","_col2"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_364] - Select Operator [SEL_363] (rows=338 width=16) + SHUFFLE [RS_368] + Select Operator [SEL_367] (rows=338 width=16) Output:["_col0","_col1","_col2"] - Group By Operator [GBY_362] (rows=338 width=12) - Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_361] - PartitionCols:_col0 - Group By Operator [GBY_360] (rows=338 width=12) - Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 - Select Operator [SEL_359] (rows=676 width=116) - Output:["_col0"] - Group By Operator [GBY_358] (rows=676 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_119] - PartitionCols:_col0 - Group By Operator [GBY_118] (rows=154128 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col5 - Merge Join Operator [MERGEJOIN_285] (rows=525327388 width=110) - Conds:RS_114._col0=RS_115._col0(Inner),Output:["_col2","_col5"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_115] - PartitionCols:_col0 - Select Operator [SEL_104] (rows=5072841 width=12) - Output:["_col0"] - Filter Operator [FIL_103] (rows=5072841 width=12) - predicate:(_col1 <= _col3) - Merge Join Operator [MERGEJOIN_283] (rows=15218525 width=12) - Conds:(Inner),Output:["_col0","_col1","_col3"] - <-Reducer 15 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_100] - Filter Operator [FIL_99] (rows=608741 width=12) - predicate:(_col2 <= _col1) - Merge Join Operator [MERGEJOIN_280] (rows=1826225 width=12) - Conds:(Inner),Output:["_col0","_col1","_col2"] - <-Map 33 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_355] - Select Operator [SEL_354] (rows=73049 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_353] (rows=73049 width=8) - predicate:d_month_seq is not null - TableScan [TS_77] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Reducer 14 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_352] - Group By Operator [GBY_351] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_312] - PartitionCols:_col0 - Group By Operator [GBY_308] (rows=25 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_304] (rows=50 width=12) - Output:["_col0"] - Filter Operator [FIL_300] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] - <-Reducer 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_357] - Group By Operator [GBY_356] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_313] - PartitionCols:_col0 - Group By Operator [GBY_309] (rows=25 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_305] (rows=50 width=12) - Output:["_col0"] - Filter Operator [FIL_301] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) - Please refer to the previous TableScan [TS_3] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_114] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_284] (rows=525327388 width=114) - Conds:RS_111._col1=RS_112._col0(Inner),Output:["_col0","_col2","_col5"] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_112] + Top N Key Operator [TNK_366] (rows=338 width=12) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_365] (rows=338 width=12) + Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 + Top N Key Operator [TNK_364] (rows=338 width=12) + keys:KEY._col0,top n:100 + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_363] + PartitionCols:_col0 + Group By Operator [GBY_362] (rows=338 width=12) + Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 + Select Operator [SEL_361] (rows=676 width=116) + Output:["_col0"] + Group By Operator [GBY_360] (rows=676 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_119] + PartitionCols:_col0 + Group By Operator [GBY_118] (rows=154128 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col5 + Merge Join Operator [MERGEJOIN_287] (rows=525327388 width=110) + Conds:RS_114._col0=RS_115._col0(Inner),Output:["_col2","_col5"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_115] PartitionCols:_col0 - Select Operator [SEL_76] (rows=4049224 width=4) + Select Operator [SEL_104] (rows=5072841 width=12) Output:["_col0"] - Merge Join Operator [MERGEJOIN_282] (rows=4049224 width=4) - Conds:RS_73._col0=RS_350._col1(Inner),Output:["_col5"] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_73] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_276] (rows=39720279 width=4) - Conds:RS_332._col1, _col2=RS_335._col0, _col1(Inner),Output:["_col0"] - <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_332] - PartitionCols:_col1, _col2 - Select Operator [SEL_331] (rows=40000000 width=188) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_330] (rows=40000000 width=188) - predicate:(ca_county is not null and ca_state is not null) - TableScan [TS_33] (rows=40000000 width=188) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"] - <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_335] - PartitionCols:_col0, _col1 - Select Operator [SEL_334] (rows=1704 width=184) - Output:["_col0","_col1"] - Filter Operator [FIL_333] (rows=1704 width=184) - predicate:(s_county is not null and s_state is not null) - TableScan [TS_36] (rows=1704 width=184) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"] - <-Reducer 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_350] - PartitionCols:_col1 - Select Operator [SEL_349] (rows=4049224 width=8) - Output:["_col0","_col1"] - Group By Operator [GBY_348] (rows=4049224 width=8) - Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 - <-Reducer 26 [SIMPLE_EDGE] - SHUFFLE [RS_67] - PartitionCols:_col0, _col1 - Group By Operator [GBY_66] (rows=4049224 width=8) - Output:["_col0","_col1"],keys:_col6, _col5 - Merge Join Operator [MERGEJOIN_279] (rows=4049224 width=8) - Conds:RS_62._col1=RS_347._col0(Inner),Output:["_col5","_col6"] - <-Map 32 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_347] + Filter Operator [FIL_103] (rows=5072841 width=12) + predicate:(_col1 <= _col3) + Merge Join Operator [MERGEJOIN_285] (rows=15218525 width=12) + Conds:(Inner),Output:["_col0","_col1","_col3"] + <-Reducer 15 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_100] + Filter Operator [FIL_99] (rows=608741 width=12) + predicate:(_col2 <= _col1) + Merge Join Operator [MERGEJOIN_282] (rows=1826225 width=12) + Conds:(Inner),Output:["_col0","_col1","_col2"] + <-Map 33 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_357] + Select Operator [SEL_356] (rows=73049 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_355] (rows=73049 width=8) + predicate:d_month_seq is not null + TableScan [TS_77] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Reducer 14 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_354] + Group By Operator [GBY_353] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_314] PartitionCols:_col0 - Select Operator [SEL_346] (rows=80000000 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_345] (rows=80000000 width=8) - predicate:c_current_addr_sk is not null - TableScan [TS_53] (rows=80000000 width=8) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] - <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_62] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_278] (rows=4049224 width=1) - Conds:RS_59._col2=RS_344._col0(Inner),Output:["_col1"] - <-Map 31 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] + Group By Operator [GBY_310] (rows=25 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_306] (rows=50 width=12) + Output:["_col0"] + Filter Operator [FIL_302] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] + <-Reducer 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_359] + Group By Operator [GBY_358] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_315] + PartitionCols:_col0 + Group By Operator [GBY_311] (rows=25 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_307] (rows=50 width=12) + Output:["_col0"] + Filter Operator [FIL_303] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) + Please refer to the previous TableScan [TS_3] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_114] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_286] (rows=525327388 width=114) + Conds:RS_111._col1=RS_112._col0(Inner),Output:["_col0","_col2","_col5"] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_112] + PartitionCols:_col0 + Select Operator [SEL_76] (rows=4049224 width=4) + Output:["_col0"] + Merge Join Operator [MERGEJOIN_284] (rows=4049224 width=4) + Conds:RS_73._col0=RS_352._col1(Inner),Output:["_col5"] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_73] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_278] (rows=39720279 width=4) + Conds:RS_334._col1, _col2=RS_337._col0, _col1(Inner),Output:["_col0"] + <-Map 18 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_334] + PartitionCols:_col1, _col2 + Select Operator [SEL_333] (rows=40000000 width=188) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_332] (rows=40000000 width=188) + predicate:(ca_county is not null and ca_state is not null) + TableScan [TS_33] (rows=40000000 width=188) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"] + <-Map 21 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_337] + PartitionCols:_col0, _col1 + Select Operator [SEL_336] (rows=1704 width=184) + Output:["_col0","_col1"] + Filter Operator [FIL_335] (rows=1704 width=184) + predicate:(s_county is not null and s_state is not null) + TableScan [TS_36] (rows=1704 width=184) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"] + <-Reducer 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_352] + PartitionCols:_col1 + Select Operator [SEL_351] (rows=4049224 width=8) + Output:["_col0","_col1"] + Group By Operator [GBY_350] (rows=4049224 width=8) + Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 + <-Reducer 26 [SIMPLE_EDGE] + SHUFFLE [RS_67] + PartitionCols:_col0, _col1 + Group By Operator [GBY_66] (rows=4049224 width=8) + Output:["_col0","_col1"],keys:_col6, _col5 + Merge Join Operator [MERGEJOIN_281] (rows=4049224 width=8) + Conds:RS_62._col1=RS_349._col0(Inner),Output:["_col5","_col6"] + <-Map 32 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] PartitionCols:_col0 - Select Operator [SEL_343] (rows=453 width=4) - Output:["_col0"] - Filter Operator [FIL_342] (rows=453 width=186) - predicate:((i_class = 'consignment') and (i_category = 'Jewelry')) - TableScan [TS_50] (rows=462000 width=186) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] - <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_59] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_277] (rows=429048824 width=7) - Conds:Union 23._col0=RS_338._col0(Inner),Output:["_col1","_col2"] - <-Map 29 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_338] + Select Operator [SEL_348] (rows=80000000 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_347] (rows=80000000 width=8) + predicate:c_current_addr_sk is not null + TableScan [TS_53] (rows=80000000 width=8) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] + <-Reducer 25 [SIMPLE_EDGE] + SHUFFLE [RS_62] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_280] (rows=4049224 width=1) + Conds:RS_59._col2=RS_346._col0(Inner),Output:["_col1"] + <-Map 31 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_346] PartitionCols:_col0 - Select Operator [SEL_337] (rows=50 width=4) + Select Operator [SEL_345] (rows=453 width=4) Output:["_col0"] - Filter Operator [FIL_336] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3)) - TableScan [TS_47] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Union 23 [SIMPLE_EDGE] - <-Map 22 [CONTAINS] vectorized - Reduce Output Operator [RS_373] - PartitionCols:_col0 - Select Operator [SEL_372] (rows=285117831 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_371] (rows=285117831 width=11) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_286] (rows=287989836 width=11) - Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"] - <-Reducer 30 [BROADCAST_EDGE] vectorized - BROADCAST [RS_369] - Group By Operator [GBY_368] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 29 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_341] - Group By Operator [GBY_340] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_339] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_337] - <-Map 28 [CONTAINS] vectorized - Reduce Output Operator [RS_376] - PartitionCols:_col0 - Select Operator [SEL_375] (rows=143930993 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_374] (rows=143930993 width=11) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_291] (rows=144002668 width=11) - Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"] - <-Reducer 30 [BROADCAST_EDGE] vectorized - BROADCAST [RS_370] - Please refer to the previous Group By Operator [GBY_368] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_111] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_281] (rows=525327388 width=114) - Conds:(Inner),Output:["_col0","_col1","_col2"] - <-Reducer 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_329] - Select Operator [SEL_328] (rows=1 width=8) - Filter Operator [FIL_327] (rows=1 width=8) - predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_326] (rows=1 width=8) - Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_325] - Group By Operator [GBY_324] (rows=1 width=8) - Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_323] (rows=25 width=4) - Group By Operator [GBY_322] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_311] - PartitionCols:_col0 - Group By Operator [GBY_307] (rows=25 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_303] (rows=50 width=12) - Output:["_col0"] - Filter Operator [FIL_299] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3)) - Please refer to the previous TableScan [TS_3] - <-Reducer 2 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_108] - Merge Join Operator [MERGEJOIN_275] (rows=525327388 width=114) + Filter Operator [FIL_344] (rows=453 width=186) + predicate:((i_class = 'consignment') and (i_category = 'Jewelry')) + TableScan [TS_50] (rows=462000 width=186) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] + <-Reducer 24 [SIMPLE_EDGE] + SHUFFLE [RS_59] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_279] (rows=429048824 width=7) + Conds:Union 23._col0=RS_340._col0(Inner),Output:["_col1","_col2"] + <-Map 29 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_340] + PartitionCols:_col0 + Select Operator [SEL_339] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_338] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3)) + TableScan [TS_47] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Union 23 [SIMPLE_EDGE] + <-Map 22 [CONTAINS] vectorized + Reduce Output Operator [RS_377] + PartitionCols:_col0 + Select Operator [SEL_376] (rows=285117831 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_375] (rows=285117831 width=11) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_288] (rows=287989836 width=11) + Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"] + <-Reducer 30 [BROADCAST_EDGE] vectorized + BROADCAST [RS_373] + Group By Operator [GBY_372] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 29 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_343] + Group By Operator [GBY_342] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_341] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_339] + <-Map 28 [CONTAINS] vectorized + Reduce Output Operator [RS_380] + PartitionCols:_col0 + Select Operator [SEL_379] (rows=143930993 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_378] (rows=143930993 width=11) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_293] (rows=144002668 width=11) + Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"] + <-Reducer 30 [BROADCAST_EDGE] vectorized + BROADCAST [RS_374] + Please refer to the previous Group By Operator [GBY_372] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_111] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_283] (rows=525327388 width=114) Conds:(Inner),Output:["_col0","_col1","_col2"] - <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_298] - Select Operator [SEL_297] (rows=525327388 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_296] (rows=525327388 width=114) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"] - <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_321] - Select Operator [SEL_320] (rows=1 width=8) - Filter Operator [FIL_319] (rows=1 width=8) + <-Reducer 13 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_331] + Select Operator [SEL_330] (rows=1 width=8) + Filter Operator [FIL_329] (rows=1 width=8) predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_318] (rows=1 width=8) + Group By Operator [GBY_328] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Reducer 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_317] - Group By Operator [GBY_316] (rows=1 width=8) + <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_327] + Group By Operator [GBY_326] (rows=1 width=8) Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_315] (rows=25 width=4) - Group By Operator [GBY_314] (rows=25 width=4) + Select Operator [SEL_325] (rows=25 width=4) + Group By Operator [GBY_324] (rows=25 width=4) Output:["_col0"],keys:KEY._col0 <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_310] + SHUFFLE [RS_313] PartitionCols:_col0 - Group By Operator [GBY_306] (rows=25 width=4) + Group By Operator [GBY_309] (rows=25 width=4) Output:["_col0"],keys:_col0 - Select Operator [SEL_302] (rows=50 width=12) + Select Operator [SEL_305] (rows=50 width=12) Output:["_col0"] - Please refer to the previous Filter Operator [FIL_299] + Filter Operator [FIL_301] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3)) + Please refer to the previous TableScan [TS_3] + <-Reducer 2 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_108] + Merge Join Operator [MERGEJOIN_277] (rows=525327388 width=114) + Conds:(Inner),Output:["_col0","_col1","_col2"] + <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_300] + Select Operator [SEL_299] (rows=525327388 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_298] (rows=525327388 width=114) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"] + <-Reducer 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_323] + Select Operator [SEL_322] (rows=1 width=8) + Filter Operator [FIL_321] (rows=1 width=8) + predicate:(sq_count_check(_col0) <= 1) + Group By Operator [GBY_320] (rows=1 width=8) + Output:["_col0"],aggregations:["count(VALUE._col0)"] + <-Reducer 10 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_319] + Group By Operator [GBY_318] (rows=1 width=8) + Output:["_col0"],aggregations:["count()"] + Select Operator [SEL_317] (rows=25 width=4) + Group By Operator [GBY_316] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_312] + PartitionCols:_col0 + Group By Operator [GBY_308] (rows=25 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_304] (rows=50 width=12) + Output:["_col0"] + Please refer to the previous Filter Operator [FIL_301] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query55.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query55.q.out index fb52de2aba..26137dfe9f 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query55.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query55.q.out @@ -47,65 +47,67 @@ Stage-0 limit:-1 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Limit [LIM_73] (rows=100 width=220) + File Output Operator [FS_76] + Limit [LIM_75] (rows=100 width=220) Number of rows:100 - Select Operator [SEL_72] (rows=7333 width=220) + Select Operator [SEL_74] (rows=7333 width=220) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - Select Operator [SEL_70] (rows=7333 width=220) + SHUFFLE [RS_73] + Select Operator [SEL_72] (rows=7333 width=220) Output:["_col1","_col2","_col3"] - Group By Operator [GBY_69] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1 - Group By Operator [GBY_16] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 - Merge Join Operator [MERGEJOIN_54] (rows=84037218 width=183) - Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_68] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=7333 width=107) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_66] (rows=7333 width=111) - predicate:(i_manager_id = 36) - TableScan [TS_6] (rows=462000 width=111) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_53] (rows=550076554 width=110) - Conds:RS_65._col0=RS_57._col0(Inner),Output:["_col1","_col2"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_57] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_55] (rows=50 width=12) - predicate:((d_year = 2001) and (d_moy = 12)) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_63] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_62] - Group By Operator [GBY_61] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_60] - Group By Operator [GBY_59] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_58] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_56] + Top N Key Operator [TNK_71] (rows=7333 width=216) + keys:_col2, _col0,top n:100 + Group By Operator [GBY_70] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1 + Group By Operator [GBY_16] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 + Merge Join Operator [MERGEJOIN_55] (rows=84037218 width=183) + Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] + PartitionCols:_col0 + Select Operator [SEL_68] (rows=7333 width=107) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_67] (rows=7333 width=111) + predicate:(i_manager_id = 36) + TableScan [TS_6] (rows=462000 width=111) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_54] (rows=550076554 width=110) + Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_56] (rows=50 width=12) + predicate:((d_year = 2001) and (d_moy = 12)) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query56.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query56.q.out index cd438d4ae3..e9b34e632e 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query56.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query56.q.out @@ -177,222 +177,224 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_353] - Limit [LIM_352] (rows=100 width=212) + File Output Operator [FS_355] + Limit [LIM_354] (rows=100 width=212) Number of rows:100 - Select Operator [SEL_351] (rows=355 width=212) + Select Operator [SEL_353] (rows=355 width=212) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_350] - Group By Operator [GBY_349] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 11 [CONTAINS] vectorized - Reduce Output Operator [RS_369] - PartitionCols:_col0 - Group By Operator [GBY_368] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_367] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col0 - Group By Operator [GBY_105] (rows=9585 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_301] (rows=31485548 width=211) - Conds:RS_101._col0=RS_102._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_101] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_290] (rows=15609 width=104) - Conds:RS_315._col1=RS_321._col0(Inner),Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_315] - PartitionCols:_col1 - Select Operator [SEL_314] (rows=462000 width=104) - Output:["_col0","_col1"] - TableScan [TS_0] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_321] - PartitionCols:_col0 - Group By Operator [GBY_320] (rows=10500 width=100) - Output:["_col0"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col0 - Group By Operator [GBY_318] (rows=10500 width=100) - Output:["_col0"],keys:i_item_id - Select Operator [SEL_317] (rows=21000 width=189) - Output:["i_item_id"] - Filter Operator [FIL_316] (rows=21000 width=189) - predicate:(i_color) IN ('orchid', 'chiffon', 'lace') - TableScan [TS_2] (rows=462000 width=189) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_color"] - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_102] - PartitionCols:_col2 - Select Operator [SEL_97] (rows=143931246 width=115) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_298] (rows=143931246 width=115) - Conds:RS_94._col2=RS_345._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_345] - PartitionCols:_col0 - Select Operator [SEL_342] (rows=8000000 width=4) - Output:["_col0"] - Filter Operator [FIL_341] (rows=8000000 width=112) - predicate:(ca_gmt_offset = -8) - TableScan [TS_15] (rows=40000000 width=112) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_94] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_297] (rows=143931246 width=119) - Conds:RS_366._col0=RS_328._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_328] - PartitionCols:_col0 - Select Operator [SEL_323] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_322] (rows=50 width=12) - predicate:((d_year = 2000) and (d_moy = 1)) - TableScan [TS_12] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_366] - PartitionCols:_col0 - Select Operator [SEL_365] (rows=143931246 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_364] (rows=143931246 width=123) - predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_92_date_dim_d_date_sk_min) AND DynamicValue(RS_92_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_92_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_82] (rows=144002668 width=123) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_363] - Group By Operator [GBY_362] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_335] - Group By Operator [GBY_332] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_329] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_323] - <-Reducer 4 [CONTAINS] vectorized - Reduce Output Operator [RS_348] - PartitionCols:_col0 - Group By Operator [GBY_347] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_346] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col0 - Group By Operator [GBY_32] (rows=30175 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_299] (rows=114917468 width=188) - Conds:RS_28._col0=RS_29._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_28] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_290] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col2 - Select Operator [SEL_24] (rows=525327191 width=110) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_292] (rows=525327191 width=110) - Conds:RS_21._col2=RS_343._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_343] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_342] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_291] (rows=525327191 width=114) - Conds:RS_340._col0=RS_324._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_324] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_323] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_340] - PartitionCols:_col0 - Select Operator [SEL_339] (rows=525327191 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_338] (rows=525327191 width=118) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_19_date_dim_d_date_sk_min) AND DynamicValue(RS_19_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_19_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_9] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_337] - Group By Operator [GBY_336] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_333] - Group By Operator [GBY_330] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_325] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_323] - <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_361] - PartitionCols:_col0 - Group By Operator [GBY_360] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_359] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_69] - PartitionCols:_col0 - Group By Operator [GBY_68] (rows=18460 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_300] (rows=62370668 width=209) - Conds:RS_64._col0=RS_65._col3(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_64] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_290] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_65] - PartitionCols:_col3 - Select Operator [SEL_60] (rows=285117733 width=115) - Output:["_col3","_col4"] - Merge Join Operator [MERGEJOIN_295] (rows=285117733 width=115) - Conds:RS_57._col1=RS_344._col0(Inner),Output:["_col2","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_342] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_57] + SHUFFLE [RS_352] + Top N Key Operator [TNK_351] (rows=355 width=212) + keys:_col1,top n:100 + Group By Operator [GBY_350] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 11 [CONTAINS] vectorized + Reduce Output Operator [RS_371] + PartitionCols:_col0 + Group By Operator [GBY_370] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_369] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_106] + PartitionCols:_col0 + Group By Operator [GBY_105] (rows=9585 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_302] (rows=31485548 width=211) + Conds:RS_101._col0=RS_102._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_101] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_291] (rows=15609 width=104) + Conds:RS_316._col1=RS_322._col0(Inner),Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_316] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_294] (rows=285117733 width=119) - Conds:RS_358._col0=RS_326._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_326] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_323] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_358] + Select Operator [SEL_315] (rows=462000 width=104) + Output:["_col0","_col1"] + TableScan [TS_0] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_322] + PartitionCols:_col0 + Group By Operator [GBY_321] (rows=10500 width=100) + Output:["_col0"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_320] PartitionCols:_col0 - Select Operator [SEL_357] (rows=285117733 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_356] (rows=285117733 width=123) - predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_55_date_dim_d_date_sk_min) AND DynamicValue(RS_55_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_55_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_45] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_355] - Group By Operator [GBY_354] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_334] - Group By Operator [GBY_331] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_327] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_323] + Group By Operator [GBY_319] (rows=10500 width=100) + Output:["_col0"],keys:i_item_id + Select Operator [SEL_318] (rows=21000 width=189) + Output:["i_item_id"] + Filter Operator [FIL_317] (rows=21000 width=189) + predicate:(i_color) IN ('orchid', 'chiffon', 'lace') + TableScan [TS_2] (rows=462000 width=189) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_color"] + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_102] + PartitionCols:_col2 + Select Operator [SEL_97] (rows=143931246 width=115) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_299] (rows=143931246 width=115) + Conds:RS_94._col2=RS_346._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_346] + PartitionCols:_col0 + Select Operator [SEL_343] (rows=8000000 width=4) + Output:["_col0"] + Filter Operator [FIL_342] (rows=8000000 width=112) + predicate:(ca_gmt_offset = -8) + TableScan [TS_15] (rows=40000000 width=112) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_94] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_298] (rows=143931246 width=119) + Conds:RS_368._col0=RS_329._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_329] + PartitionCols:_col0 + Select Operator [SEL_324] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_323] (rows=50 width=12) + predicate:((d_year = 2000) and (d_moy = 1)) + TableScan [TS_12] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_368] + PartitionCols:_col0 + Select Operator [SEL_367] (rows=143931246 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_366] (rows=143931246 width=123) + predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_92_date_dim_d_date_sk_min) AND DynamicValue(RS_92_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_92_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_82] (rows=144002668 width=123) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_365] + Group By Operator [GBY_364] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_336] + Group By Operator [GBY_333] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_330] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_324] + <-Reducer 4 [CONTAINS] vectorized + Reduce Output Operator [RS_349] + PartitionCols:_col0 + Group By Operator [GBY_348] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_347] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col0 + Group By Operator [GBY_32] (rows=30175 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_300] (rows=114917468 width=188) + Conds:RS_28._col0=RS_29._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_28] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_291] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col2 + Select Operator [SEL_24] (rows=525327191 width=110) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_293] (rows=525327191 width=110) + Conds:RS_21._col2=RS_344._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_344] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_343] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_292] (rows=525327191 width=114) + Conds:RS_341._col0=RS_325._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_325] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_324] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_341] + PartitionCols:_col0 + Select Operator [SEL_340] (rows=525327191 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_339] (rows=525327191 width=118) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_19_date_dim_d_date_sk_min) AND DynamicValue(RS_19_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_19_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_9] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_338] + Group By Operator [GBY_337] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_334] + Group By Operator [GBY_331] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_326] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_324] + <-Reducer 9 [CONTAINS] vectorized + Reduce Output Operator [RS_363] + PartitionCols:_col0 + Group By Operator [GBY_362] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_361] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_69] + PartitionCols:_col0 + Group By Operator [GBY_68] (rows=18460 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_301] (rows=62370668 width=209) + Conds:RS_64._col0=RS_65._col3(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_64] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_291] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_65] + PartitionCols:_col3 + Select Operator [SEL_60] (rows=285117733 width=115) + Output:["_col3","_col4"] + Merge Join Operator [MERGEJOIN_296] (rows=285117733 width=115) + Conds:RS_57._col1=RS_345._col0(Inner),Output:["_col2","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_345] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_343] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_57] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_295] (rows=285117733 width=119) + Conds:RS_360._col0=RS_327._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_327] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_324] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_360] + PartitionCols:_col0 + Select Operator [SEL_359] (rows=285117733 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_358] (rows=285117733 width=123) + predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_55_date_dim_d_date_sk_min) AND DynamicValue(RS_55_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_55_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_45] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 21 [BROADCAST_EDGE] vectorized + BROADCAST [RS_357] + Group By Operator [GBY_356] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_335] + Group By Operator [GBY_332] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_328] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_324] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out index 7896f97fed..15b6f1a232 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query57.q.out @@ -123,138 +123,140 @@ Stage-0 limit:-1 Stage-1 Reducer 8 vectorized - File Output Operator [FS_321] - Limit [LIM_320] (rows=100 width=758) + File Output Operator [FS_322] + Limit [LIM_321] (rows=100 width=758) Number of rows:100 - Select Operator [SEL_319] (rows=397735 width=758) + Select Operator [SEL_320] (rows=397735 width=758) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_110] Select Operator [SEL_109] (rows=397735 width=758) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_278] (rows=397735 width=646) - Conds:RS_106._col5, _col6, _col12, _col7=RS_306._col0, _col1, _col4, _col2(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col10","_col11","_col16"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_306] - PartitionCols:_col0, _col1, _col4, _col2 - Select Operator [SEL_304] (rows=2386410 width=404) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_302] (rows=2386410 width=408) - predicate:rank_window_0 is not null - PTF Operator [PTF_300] (rows=2386410 width=408) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col4, _col3, _col2"}] - Select Operator [SEL_299] (rows=2386410 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_297] - PartitionCols:_col4, _col3, _col2 - Group By Operator [GBY_296] (rows=2386410 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_93] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_92] (rows=285117980 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col8, _col10, _col11 - Merge Join Operator [MERGEJOIN_276] (rows=285117980 width=407) - Conds:RS_88._col2=RS_295._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10","_col11"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_295] - PartitionCols:_col0 - Select Operator [SEL_294] (rows=462000 width=194) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_293] (rows=462000 width=194) - predicate:(i_category is not null and i_brand is not null) - TableScan [TS_79] (rows=462000 width=194) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_275] (rows=285117980 width=221) - Conds:RS_85._col1=RS_292._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_292] - PartitionCols:_col0 - Select Operator [SEL_291] (rows=60 width=102) - Output:["_col0","_col1"] - Filter Operator [FIL_290] (rows=60 width=102) - predicate:cc_name is not null - TableScan [TS_76] (rows=60 width=102) - default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_274] (rows=285117980 width=127) - Conds:RS_289._col0=RS_281._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] - PartitionCols:_col0 - Select Operator [SEL_280] (rows=564 width=12) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_279] (rows=564 width=12) - predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1)))) - TableScan [TS_73] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_289] - PartitionCols:_col0 - Select Operator [SEL_288] (rows=285117980 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_287] (rows=285117980 width=123) - predicate:(cs_sold_date_sk is not null and cs_call_center_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_70] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_item_sk","cs_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_286] - Group By Operator [GBY_285] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] - Group By Operator [GBY_283] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_282] (rows=564 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_280] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col5, _col6, _col12, _col7 - Merge Join Operator [MERGEJOIN_277] (rows=397735 width=636) - Conds:RS_307._col0, _col1, _col4, _col2=RS_318._col0, _col1, _col7, _col2(Inner),Output:["_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_307] - PartitionCols:_col0, _col1, _col4, _col2 - Select Operator [SEL_305] (rows=2386410 width=404) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_303] (rows=2386410 width=408) - predicate:rank_window_0 is not null - PTF Operator [PTF_301] (rows=2386410 width=408) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col4, _col3, _col2"}] - Please refer to the previous Select Operator [SEL_299] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] - PartitionCols:_col0, _col1, _col7, _col2 - Select Operator [SEL_317] (rows=397735 width=524) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_316] (rows=397735 width=524) - predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col6 - _col0)) / _col0) > 0.1)) ELSE (false) END - Select Operator [SEL_315] (rows=795470 width=520) - Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_314] (rows=795470 width=520) - predicate:((_col0 > 0) and rank_window_1 is not null and (_col1 = 2000)) - PTF Operator [PTF_313] (rows=2386410 width=520) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST, _col2 ASC NULLS LAST","partition by:":"_col5, _col4, _col3"}] - Select Operator [SEL_312] (rows=2386410 width=520) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_311] - PartitionCols:_col4, _col3, _col2 - Select Operator [SEL_310] (rows=2386410 width=408) - Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_309] (rows=2386410 width=408) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col4 ASC NULLS FIRST, _col3 ASC NULLS FIRST, _col2 ASC NULLS FIRST, _col0 ASC NULLS FIRST","partition by:":"_col4, _col3, _col2, _col0"}] - Select Operator [SEL_308] (rows=2386410 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_298] - PartitionCols:_col4, _col3, _col2, _col0 - Please refer to the previous Group By Operator [GBY_296] + Top N Key Operator [TNK_178] (rows=397735 width=646) + keys:(_col10 - _col11), _col8,top n:100 + Merge Join Operator [MERGEJOIN_279] (rows=397735 width=646) + Conds:RS_106._col5, _col6, _col12, _col7=RS_307._col0, _col1, _col4, _col2(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col10","_col11","_col16"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_307] + PartitionCols:_col0, _col1, _col4, _col2 + Select Operator [SEL_305] (rows=2386410 width=404) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_303] (rows=2386410 width=408) + predicate:rank_window_0 is not null + PTF Operator [PTF_301] (rows=2386410 width=408) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col4, _col3, _col2"}] + Select Operator [SEL_300] (rows=2386410 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_298] + PartitionCols:_col4, _col3, _col2 + Group By Operator [GBY_297] (rows=2386410 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_93] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_92] (rows=285117980 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col8, _col10, _col11 + Merge Join Operator [MERGEJOIN_277] (rows=285117980 width=407) + Conds:RS_88._col2=RS_296._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10","_col11"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_296] + PartitionCols:_col0 + Select Operator [SEL_295] (rows=462000 width=194) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_294] (rows=462000 width=194) + predicate:(i_category is not null and i_brand is not null) + TableScan [TS_79] (rows=462000 width=194) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_276] (rows=285117980 width=221) + Conds:RS_85._col1=RS_293._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_293] + PartitionCols:_col0 + Select Operator [SEL_292] (rows=60 width=102) + Output:["_col0","_col1"] + Filter Operator [FIL_291] (rows=60 width=102) + predicate:cc_name is not null + TableScan [TS_76] (rows=60 width=102) + default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_275] (rows=285117980 width=127) + Conds:RS_290._col0=RS_282._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_282] + PartitionCols:_col0 + Select Operator [SEL_281] (rows=564 width=12) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_280] (rows=564 width=12) + predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1)))) + TableScan [TS_73] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_290] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=285117980 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_288] (rows=285117980 width=123) + predicate:(cs_sold_date_sk is not null and cs_call_center_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_70] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_item_sk","cs_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_287] + Group By Operator [GBY_286] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_285] + Group By Operator [GBY_284] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_283] (rows=564 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_281] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_106] + PartitionCols:_col5, _col6, _col12, _col7 + Merge Join Operator [MERGEJOIN_278] (rows=397735 width=636) + Conds:RS_308._col0, _col1, _col4, _col2=RS_319._col0, _col1, _col7, _col2(Inner),Output:["_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_308] + PartitionCols:_col0, _col1, _col4, _col2 + Select Operator [SEL_306] (rows=2386410 width=404) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_304] (rows=2386410 width=408) + predicate:rank_window_0 is not null + PTF Operator [PTF_302] (rows=2386410 width=408) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS LAST, _col1 ASC NULLS LAST","partition by:":"_col4, _col3, _col2"}] + Please refer to the previous Select Operator [SEL_300] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_319] + PartitionCols:_col0, _col1, _col7, _col2 + Select Operator [SEL_318] (rows=397735 width=524) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_317] (rows=397735 width=524) + predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col6 - _col0)) / _col0) > 0.1)) ELSE (false) END + Select Operator [SEL_316] (rows=795470 width=520) + Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_315] (rows=795470 width=520) + predicate:((_col0 > 0) and rank_window_1 is not null and (_col1 = 2000)) + PTF Operator [PTF_314] (rows=2386410 width=520) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST, _col2 ASC NULLS LAST","partition by:":"_col5, _col4, _col3"}] + Select Operator [SEL_313] (rows=2386410 width=520) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_312] + PartitionCols:_col4, _col3, _col2 + Select Operator [SEL_311] (rows=2386410 width=408) + Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5"] + PTF Operator [PTF_310] (rows=2386410 width=408) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col4 ASC NULLS FIRST, _col3 ASC NULLS FIRST, _col2 ASC NULLS FIRST, _col0 ASC NULLS FIRST","partition by:":"_col4, _col3, _col2, _col0"}] + Select Operator [SEL_309] (rows=2386410 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_299] + PartitionCols:_col4, _col3, _col2, _col0 + Please refer to the previous Group By Operator [GBY_297] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query58.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query58.q.out index 5fa126bf6e..7a2565000b 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query58.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query58.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[406][tables = [$hdt$_3, $hdt$_4]] in Stage 'Reducer 20' is a cross product +Warning: Shuffle Join MERGEJOIN[407][tables = [$hdt$_3, $hdt$_4]] in Stage 'Reducer 20' is a cross product PREHOOK: query: explain with ss_items as (select i_item_id item_id @@ -171,223 +171,225 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_470] - Limit [LIM_469] (rows=1 width=884) + File Output Operator [FS_471] + Limit [LIM_470] (rows=1 width=884) Number of rows:100 - Select Operator [SEL_468] (rows=1 width=884) + Select Operator [SEL_469] (rows=1 width=884) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_157] Select Operator [SEL_156] (rows=1 width=884) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_152] (rows=1 width=660) - predicate:(_col5 BETWEEN (0.9 * _col1) AND (1.1 * _col1) and _col5 BETWEEN (0.9 * _col3) AND (1.1 * _col3) and _col1 BETWEEN _col6 AND _col7 and _col3 BETWEEN _col6 AND _col7) - Merge Join Operator [MERGEJOIN_422] (rows=3836 width=660) - Conds:RS_149._col0=RS_467._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6","_col7"] - <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_467] - PartitionCols:_col0 - Select Operator [SEL_466] (rows=310774 width=436) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_465] (rows=310774 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_141] - PartitionCols:_col0 - Group By Operator [GBY_140] (rows=37292880 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 - Merge Join Operator [MERGEJOIN_420] (rows=143966864 width=211) - Conds:RS_136._col4=RS_450._col0(Inner),Output:["_col5","_col7"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_450] + Top N Key Operator [TNK_263] (rows=1 width=660) + keys:_col0, _col3,top n:100 + Filter Operator [FIL_152] (rows=1 width=660) + predicate:(_col5 BETWEEN (0.9 * _col1) AND (1.1 * _col1) and _col5 BETWEEN (0.9 * _col3) AND (1.1 * _col3) and _col1 BETWEEN _col6 AND _col7 and _col3 BETWEEN _col6 AND _col7) + Merge Join Operator [MERGEJOIN_423] (rows=3836 width=660) + Conds:RS_149._col0=RS_468._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6","_col7"] + <-Reducer 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_468] + PartitionCols:_col0 + Select Operator [SEL_467] (rows=310774 width=436) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_466] (rows=310774 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_141] + PartitionCols:_col0 + Group By Operator [GBY_140] (rows=37292880 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 + Merge Join Operator [MERGEJOIN_421] (rows=143966864 width=211) + Conds:RS_136._col4=RS_451._col0(Inner),Output:["_col5","_col7"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_451] + PartitionCols:_col0 + Select Operator [SEL_448] (rows=462000 width=104) + Output:["_col0","_col1"] + TableScan [TS_32] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_136] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_420] (rows=143966864 width=115) + Conds:RS_133._col0=RS_465._col0(Inner),Output:["_col4","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_133] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_409] (rows=2 width=4) + Conds:RS_426._col1=RS_442._col0(Inner),Output:["_col0"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_426] + PartitionCols:_col1 + Select Operator [SEL_425] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_424] (rows=73049 width=98) + predicate:d_date is not null + TableScan [TS_0] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Reducer 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_442] + PartitionCols:_col0 + Group By Operator [GBY_441] (rows=2 width=94) + Output:["_col0"],keys:KEY._col0 + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_26] + PartitionCols:_col0 + Group By Operator [GBY_25] (rows=2 width=94) + Output:["_col0"],keys:_col2 + Merge Join Operator [MERGEJOIN_408] (rows=5 width=94) + Conds:RS_21._col1=RS_439._col1(Inner),Output:["_col2"] + <-Map 23 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_439] + PartitionCols:_col1 + Select Operator [SEL_437] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_435] (rows=73049 width=98) + predicate:(d_week_seq is not null and d_date is not null) + TableScan [TS_15] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_407] (rows=1 width=4) + Conds:(Inner),Output:["_col1"] + <-Map 23 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_440] + Select Operator [SEL_438] (rows=1 width=4) + Output:["_col0"] + Filter Operator [FIL_436] (rows=1 width=98) + predicate:((d_date = '1998-02-19') and d_week_seq is not null) + Please refer to the previous TableScan [TS_15] + <-Reducer 19 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_434] + Select Operator [SEL_433] (rows=1 width=8) + Filter Operator [FIL_432] (rows=1 width=8) + predicate:(sq_count_check(_col0) <= 1) + Group By Operator [GBY_431] (rows=1 width=8) + Output:["_col0"],aggregations:["count(VALUE._col0)"] + <-Map 18 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_430] + Group By Operator [GBY_429] (rows=1 width=8) + Output:["_col0"],aggregations:["count()"] + Select Operator [SEL_428] (rows=1 width=94) + Filter Operator [FIL_427] (rows=1 width=94) + predicate:(d_date = '1998-02-19') + TableScan [TS_3] (rows=73049 width=94) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_465] + PartitionCols:_col0 + Select Operator [SEL_464] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_463] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_133_date_dim_d_date_sk_min) AND DynamicValue(RS_133_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_133_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_125] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] + <-Reducer 17 [BROADCAST_EDGE] vectorized + BROADCAST [RS_462] + Group By Operator [GBY_461] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 2 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_387] + Group By Operator [GBY_386] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_385] (rows=2 width=4) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_409] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_149] + PartitionCols:_col0 + Filter Operator [FIL_147] (rows=3836 width=324) + predicate:(_col1 BETWEEN (0.9 * _col3) AND (1.1 * _col3) and _col3 BETWEEN (0.9 * _col1) AND (1.1 * _col1)) + Merge Join Operator [MERGEJOIN_422] (rows=310774 width=324) + Conds:RS_453._col0=RS_460._col0(Inner),Output:["_col0","_col1","_col3"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_460] + PartitionCols:_col0 + Group By Operator [GBY_459] (rows=310774 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_93] PartitionCols:_col0 - Select Operator [SEL_447] (rows=462000 width=104) - Output:["_col0","_col1"] - TableScan [TS_32] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_136] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_419] (rows=143966864 width=115) - Conds:RS_133._col0=RS_464._col0(Inner),Output:["_col4","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_133] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_408] (rows=2 width=4) - Conds:RS_425._col1=RS_441._col0(Inner),Output:["_col0"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_425] - PartitionCols:_col1 - Select Operator [SEL_424] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_423] (rows=73049 width=98) - predicate:d_date is not null - TableScan [TS_0] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Reducer 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_441] - PartitionCols:_col0 - Group By Operator [GBY_440] (rows=2 width=94) - Output:["_col0"],keys:KEY._col0 - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_26] - PartitionCols:_col0 - Group By Operator [GBY_25] (rows=2 width=94) - Output:["_col0"],keys:_col2 - Merge Join Operator [MERGEJOIN_407] (rows=5 width=94) - Conds:RS_21._col1=RS_438._col1(Inner),Output:["_col2"] - <-Map 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_438] - PartitionCols:_col1 - Select Operator [SEL_436] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_434] (rows=73049 width=98) - predicate:(d_week_seq is not null and d_date is not null) - TableScan [TS_15] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_406] (rows=1 width=4) - Conds:(Inner),Output:["_col1"] - <-Map 23 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_439] - Select Operator [SEL_437] (rows=1 width=4) - Output:["_col0"] - Filter Operator [FIL_435] (rows=1 width=98) - predicate:((d_date = '1998-02-19') and d_week_seq is not null) - Please refer to the previous TableScan [TS_15] - <-Reducer 19 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_433] - Select Operator [SEL_432] (rows=1 width=8) - Filter Operator [FIL_431] (rows=1 width=8) - predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_430] (rows=1 width=8) - Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Map 18 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_429] - Group By Operator [GBY_428] (rows=1 width=8) - Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_427] (rows=1 width=94) - Filter Operator [FIL_426] (rows=1 width=94) - predicate:(d_date = '1998-02-19') - TableScan [TS_3] (rows=73049 width=94) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_464] - PartitionCols:_col0 - Select Operator [SEL_463] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_462] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_133_date_dim_d_date_sk_min) AND DynamicValue(RS_133_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_133_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_125] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] - <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_461] - Group By Operator [GBY_460] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 2 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_386] - Group By Operator [GBY_385] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_384] (rows=2 width=4) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_408] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_149] - PartitionCols:_col0 - Filter Operator [FIL_147] (rows=3836 width=324) - predicate:(_col1 BETWEEN (0.9 * _col3) AND (1.1 * _col3) and _col3 BETWEEN (0.9 * _col1) AND (1.1 * _col1)) - Merge Join Operator [MERGEJOIN_421] (rows=310774 width=324) - Conds:RS_452._col0=RS_459._col0(Inner),Output:["_col0","_col1","_col3"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_459] - PartitionCols:_col0 - Group By Operator [GBY_458] (rows=310774 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_93] - PartitionCols:_col0 - Group By Operator [GBY_92] (rows=138294430 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 - Merge Join Operator [MERGEJOIN_415] (rows=550076554 width=206) - Conds:RS_88._col4=RS_449._col0(Inner),Output:["_col5","_col7"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_449] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_447] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_414] (rows=550076554 width=110) - Conds:RS_85._col0=RS_457._col0(Inner),Output:["_col4","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_85] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_408] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_457] - PartitionCols:_col0 - Select Operator [SEL_456] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_455] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_85_date_dim_d_date_sk_min) AND DynamicValue(RS_85_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_85_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_77] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_454] - Group By Operator [GBY_453] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 2 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_340] - Group By Operator [GBY_339] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_338] (rows=2 width=4) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_408] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_452] - PartitionCols:_col0 - Group By Operator [GBY_451] (rows=310774 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col0 - Group By Operator [GBY_44] (rows=73653438 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 - Merge Join Operator [MERGEJOIN_410] (rows=286549727 width=211) - Conds:RS_40._col4=RS_448._col0(Inner),Output:["_col5","_col7"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_448] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_447] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_409] (rows=286549727 width=115) - Conds:RS_37._col0=RS_446._col0(Inner),Output:["_col4","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_37] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_408] - <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_446] - PartitionCols:_col0 - Select Operator [SEL_445] (rows=286549727 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_444] (rows=286549727 width=119) - predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_37_date_dim_d_date_sk_min) AND DynamicValue(RS_37_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_37_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_29] (rows=287989836 width=119) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_443] - Group By Operator [GBY_442] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 2 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_290] - Group By Operator [GBY_289] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_288] (rows=2 width=4) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_408] + Group By Operator [GBY_92] (rows=138294430 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 + Merge Join Operator [MERGEJOIN_416] (rows=550076554 width=206) + Conds:RS_88._col4=RS_450._col0(Inner),Output:["_col5","_col7"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_450] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_448] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_415] (rows=550076554 width=110) + Conds:RS_85._col0=RS_458._col0(Inner),Output:["_col4","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_85] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_409] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_458] + PartitionCols:_col0 + Select Operator [SEL_457] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_456] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_85_date_dim_d_date_sk_min) AND DynamicValue(RS_85_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_85_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_77] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_455] + Group By Operator [GBY_454] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 2 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_341] + Group By Operator [GBY_340] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_339] (rows=2 width=4) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_409] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_453] + PartitionCols:_col0 + Group By Operator [GBY_452] (rows=310774 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_45] + PartitionCols:_col0 + Group By Operator [GBY_44] (rows=73653438 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 + Merge Join Operator [MERGEJOIN_411] (rows=286549727 width=211) + Conds:RS_40._col4=RS_449._col0(Inner),Output:["_col5","_col7"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_449] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_448] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_410] (rows=286549727 width=115) + Conds:RS_37._col0=RS_447._col0(Inner),Output:["_col4","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_37] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_409] + <-Map 24 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_447] + PartitionCols:_col0 + Select Operator [SEL_446] (rows=286549727 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_445] (rows=286549727 width=119) + predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_37_date_dim_d_date_sk_min) AND DynamicValue(RS_37_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_37_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_29] (rows=287989836 width=119) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 9 [BROADCAST_EDGE] vectorized + BROADCAST [RS_444] + Group By Operator [GBY_443] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 2 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_291] + Group By Operator [GBY_290] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_289] (rows=2 width=4) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_409] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query59.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query59.q.out index 82148531bc..341b40046a 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query59.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query59.q.out @@ -111,124 +111,126 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_207] - Limit [LIM_206] (rows=100 width=976) + File Output Operator [FS_208] + Limit [LIM_207] (rows=100 width=976) Number of rows:100 - Select Operator [SEL_205] (rows=862591 width=976) + Select Operator [SEL_206] (rows=862591 width=976) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_57] Select Operator [SEL_56] (rows=862591 width=976) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Merge Join Operator [MERGEJOIN_181] (rows=862591 width=1648) - Conds:RS_53._col11, _col0=RS_54._col1, (_col0 - 52)(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12","_col15","_col16","_col17","_col18","_col19","_col20"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_54] - PartitionCols:_col1, (_col0 - 52) - Select Operator [SEL_46] (rows=26628 width=776) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_180] (rows=26628 width=776) - Conds:RS_43._col1=RS_204._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col10"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_204] + Top N Key Operator [TNK_95] (rows=862591 width=1648) + keys:_col12, _col11, _col0,top n:100 + Merge Join Operator [MERGEJOIN_182] (rows=862591 width=1648) + Conds:RS_53._col11, _col0=RS_54._col1, (_col0 - 52)(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12","_col15","_col16","_col17","_col18","_col19","_col20"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_54] + PartitionCols:_col1, (_col0 - 52) + Select Operator [SEL_46] (rows=26628 width=776) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_181] (rows=26628 width=776) + Conds:RS_43._col1=RS_205._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col10"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_205] + PartitionCols:_col0 + Select Operator [SEL_204] (rows=1704 width=104) + Output:["_col0","_col1"] + TableScan [TS_38] (rows=1704 width=104) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_180] (rows=26628 width=676) + Conds:RS_203._col0=RS_199._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_199] + PartitionCols:_col0 + Select Operator [SEL_197] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_195] (rows=317 width=8) + predicate:(d_month_seq BETWEEN 1197 AND 1208 and d_week_seq is not null) + TableScan [TS_15] (rows=73049 width=8) + default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_week_seq"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_203] + PartitionCols:_col0 + Group By Operator [GBY_202] (rows=1104768 width=679) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col0, _col1 + Group By Operator [GBY_31] (rows=525329897 width=679) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)","sum(_col3)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 + Select Operator [SEL_29] (rows=525329897 width=138) + Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_179] (rows=525329897 width=138) + Conds:RS_186._col0=RS_191._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_186] + PartitionCols:_col0 + Select Operator [SEL_184] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_183] (rows=525329897 width=114) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_191] + PartitionCols:_col0 + Select Operator [SEL_189] (rows=73049 width=36) + Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_187] (rows=73049 width=99) + predicate:d_week_seq is not null + TableScan [TS_3] (rows=73049 width=99) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq","d_day_name"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_53] + PartitionCols:_col11, _col0 + Merge Join Operator [MERGEJOIN_178] (rows=26628 width=976) + Conds:RS_50._col1=RS_201._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_201] PartitionCols:_col0 - Select Operator [SEL_203] (rows=1704 width=104) - Output:["_col0","_col1"] - TableScan [TS_38] (rows=1704 width=104) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_43] + Select Operator [SEL_200] (rows=1704 width=192) + Output:["_col0","_col1","_col2"] + TableScan [TS_18] (rows=1704 width=192) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_50] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_179] (rows=26628 width=676) - Conds:RS_202._col0=RS_198._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_177] (rows=26628 width=788) + Conds:RS_193._col0=RS_198._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] <-Map 13 [SIMPLE_EDGE] vectorized SHUFFLE [RS_198] PartitionCols:_col0 Select Operator [SEL_196] (rows=317 width=4) Output:["_col0"] Filter Operator [FIL_194] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1197 AND 1208 and d_week_seq is not null) - TableScan [TS_15] (rows=73049 width=8) - default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_week_seq"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_202] + predicate:(d_month_seq BETWEEN 1185 AND 1196 and d_week_seq is not null) + Please refer to the previous TableScan [TS_15] + <-Reducer 3 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_193] PartitionCols:_col0 - Group By Operator [GBY_201] (rows=1104768 width=679) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_32] + Group By Operator [GBY_192] (rows=1104768 width=791) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] PartitionCols:_col0, _col1 - Group By Operator [GBY_31] (rows=525329897 width=679) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)","sum(_col3)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 - Select Operator [SEL_29] (rows=525329897 width=138) - Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_178] (rows=525329897 width=138) - Conds:RS_185._col0=RS_190._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11"] + Group By Operator [GBY_11] (rows=525329897 width=791) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 + Select Operator [SEL_9] (rows=525329897 width=142) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_176] (rows=525329897 width=142) + Conds:RS_185._col0=RS_190._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] <-Map 1 [SIMPLE_EDGE] vectorized SHUFFLE [RS_185] PartitionCols:_col0 - Select Operator [SEL_183] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_182] (rows=525329897 width=114) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] + Please refer to the previous Select Operator [SEL_184] <-Map 12 [SIMPLE_EDGE] vectorized SHUFFLE [RS_190] PartitionCols:_col0 Select Operator [SEL_188] (rows=73049 width=36) - Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_186] (rows=73049 width=99) - predicate:d_week_seq is not null - TableScan [TS_3] (rows=73049 width=99) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq","d_day_name"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_53] - PartitionCols:_col11, _col0 - Merge Join Operator [MERGEJOIN_177] (rows=26628 width=976) - Conds:RS_50._col1=RS_200._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_200] - PartitionCols:_col0 - Select Operator [SEL_199] (rows=1704 width=192) - Output:["_col0","_col1","_col2"] - TableScan [TS_18] (rows=1704 width=192) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_50] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_176] (rows=26628 width=788) - Conds:RS_192._col0=RS_197._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_197] - PartitionCols:_col0 - Select Operator [SEL_195] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_193] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1185 AND 1196 and d_week_seq is not null) - Please refer to the previous TableScan [TS_15] - <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_192] - PartitionCols:_col0 - Group By Operator [GBY_191] (rows=1104768 width=791) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0, _col1 - Group By Operator [GBY_11] (rows=525329897 width=791) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 - Select Operator [SEL_9] (rows=525329897 width=142) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_175] (rows=525329897 width=142) - Conds:RS_184._col0=RS_189._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_184] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_183] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_189] - PartitionCols:_col0 - Select Operator [SEL_187] (rows=73049 width=36) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Please refer to the previous Filter Operator [FIL_186] + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Please refer to the previous Filter Operator [FIL_187] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query6.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query6.q.out index d6031153b1..8d83692e8f 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query6.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query6.q.out @@ -1,4 +1,4 @@ -Warning: Map Join MAPJOIN[169][bigTable=?] in task 'Map 1' is a cross product +Warning: Map Join MAPJOIN[170][bigTable=?] in task 'Map 1' is a cross product PREHOOK: query: explain select a.ca_state state, count(*) cnt from customer_address a @@ -83,146 +83,148 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_234] - Limit [LIM_233] (rows=1 width=94) + File Output Operator [FS_236] + Limit [LIM_235] (rows=1 width=94) Number of rows:100 - Select Operator [SEL_232] (rows=1 width=94) + Select Operator [SEL_234] (rows=1 width=94) Output:["_col0","_col1"] <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_231] - Filter Operator [FIL_230] (rows=1 width=94) - predicate:(_col1 >= 10L) - Group By Operator [GBY_229] (rows=1 width=94) - Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_69] - PartitionCols:_col0 - Group By Operator [GBY_68] (rows=1 width=94) - Output:["_col0","_col1"],aggregations:["count()"],keys:_col4 - Map Join Operator [MAPJOIN_175] (rows=36482 width=86) - Conds:MAPJOIN_174._col5=RS_220._col0(Inner),Output:["_col4"] - <-Map 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_220] - PartitionCols:_col0 - Map Join Operator [MAPJOIN_219] (rows=660 width=4) - Conds:SEL_218._col1=RS_216._col0(Inner),Output:["_col0"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_216] - PartitionCols:_col0 - Group By Operator [GBY_215] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_188] - PartitionCols:_col0 - Group By Operator [GBY_186] (rows=25 width=4) - Output:["_col0"],keys:d_month_seq - Select Operator [SEL_184] (rows=50 width=12) - Output:["d_month_seq"] - Filter Operator [FIL_182] (rows=50 width=12) - predicate:((d_year = 2000) and (d_moy = 2) and d_month_seq is not null) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] - <-Select Operator [SEL_218] (rows=73049 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_217] (rows=73049 width=8) - predicate:d_month_seq is not null - TableScan [TS_41] (rows=73049 width=8) - default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map Join Operator [MAPJOIN_174] (rows=36482 width=86) - Conds:MERGEJOIN_170._col0=RS_62._col2(Inner),Output:["_col4","_col5"] - <-Reducer 11 [BROADCAST_EDGE] - BROADCAST [RS_62] - PartitionCols:_col2 - Select Operator [SEL_40] (rows=36482 width=0) - Output:["_col0","_col2"] - Merge Join Operator [MERGEJOIN_172] (rows=36482 width=0) - Conds:RS_214._col0=RS_228._col1(Inner),Output:["_col5","_col7"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_214] - PartitionCols:_col0 - Filter Operator [FIL_213] (rows=153611 width=227) - predicate:(_col1 > _col4) - Map Join Operator [MAPJOIN_212] (rows=460833 width=227) - Conds:SEL_211._col2=RS_209._col0(Inner),Output:["_col0","_col1","_col4"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_209] - PartitionCols:_col0 - Select Operator [SEL_208] (rows=10 width=202) - Output:["_col0","_col1"] - Filter Operator [FIL_207] (rows=10 width=210) - predicate:CAST( (_col1 / _col2) AS decimal(16,6)) is not null - Group By Operator [GBY_206] (rows=10 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_205] - PartitionCols:_col0 - Group By Operator [GBY_204] (rows=10 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(i_current_price)","count(i_current_price)"],keys:i_category - Filter Operator [FIL_203] (rows=462000 width=201) - predicate:i_category is not null - TableScan [TS_22] (rows=462000 width=201) - default@item,j,Tbl:COMPLETE,Col:COMPLETE,Output:["i_current_price","i_category"] - <-Select Operator [SEL_211] (rows=460833 width=205) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_210] (rows=460833 width=205) - predicate:(i_current_price is not null and i_category is not null) - TableScan [TS_19] (rows=462000 width=205) - default@item,i,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price","i_category"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_228] - PartitionCols:_col1 - Select Operator [SEL_227] (rows=525327388 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_226] (rows=525327388 width=11) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_65_d_d_date_sk_min) AND DynamicValue(RS_65_d_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_65_d_d_date_sk_bloom_filter))) - TableScan [TS_30] (rows=575995635 width=11) - default@store_sales,s,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk"] - <-Reducer 16 [BROADCAST_EDGE] vectorized - BROADCAST [RS_225] - Group By Operator [GBY_224] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Merge Join Operator [MERGEJOIN_170] (rows=80000000 width=90) - Conds:RS_200._col1=RS_202._col0(Inner),Output:["_col0","_col4"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_200] - PartitionCols:_col1 - Map Join Operator [MAPJOIN_199] (rows=80000000 width=8) - Conds:(Inner),Output:["_col0","_col1"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_196] - Select Operator [SEL_195] (rows=1 width=8) - Filter Operator [FIL_194] (rows=1 width=8) - predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_193] (rows=1 width=8) - Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Reducer 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_192] - Group By Operator [GBY_191] (rows=1 width=8) - Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_190] (rows=25 width=4) - Group By Operator [GBY_189] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_187] + SHUFFLE [RS_233] + Top N Key Operator [TNK_232] (rows=1 width=94) + keys:_col1,top n:100 + Filter Operator [FIL_231] (rows=1 width=94) + predicate:(_col1 >= 10L) + Group By Operator [GBY_230] (rows=1 width=94) + Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_69] + PartitionCols:_col0 + Group By Operator [GBY_68] (rows=1 width=94) + Output:["_col0","_col1"],aggregations:["count()"],keys:_col4 + Map Join Operator [MAPJOIN_176] (rows=36482 width=86) + Conds:MAPJOIN_175._col5=RS_221._col0(Inner),Output:["_col4"] + <-Map 15 [BROADCAST_EDGE] vectorized + BROADCAST [RS_221] + PartitionCols:_col0 + Map Join Operator [MAPJOIN_220] (rows=660 width=4) + Conds:SEL_219._col1=RS_217._col0(Inner),Output:["_col0"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_217] + PartitionCols:_col0 + Group By Operator [GBY_216] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_189] + PartitionCols:_col0 + Group By Operator [GBY_187] (rows=25 width=4) + Output:["_col0"],keys:d_month_seq + Select Operator [SEL_185] (rows=50 width=12) + Output:["d_month_seq"] + Filter Operator [FIL_183] (rows=50 width=12) + predicate:((d_year = 2000) and (d_moy = 2) and d_month_seq is not null) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] + <-Select Operator [SEL_219] (rows=73049 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_218] (rows=73049 width=8) + predicate:d_month_seq is not null + TableScan [TS_41] (rows=73049 width=8) + default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map Join Operator [MAPJOIN_175] (rows=36482 width=86) + Conds:MERGEJOIN_171._col0=RS_62._col2(Inner),Output:["_col4","_col5"] + <-Reducer 11 [BROADCAST_EDGE] + BROADCAST [RS_62] + PartitionCols:_col2 + Select Operator [SEL_40] (rows=36482 width=0) + Output:["_col0","_col2"] + Merge Join Operator [MERGEJOIN_173] (rows=36482 width=0) + Conds:RS_215._col0=RS_229._col1(Inner),Output:["_col5","_col7"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_215] + PartitionCols:_col0 + Filter Operator [FIL_214] (rows=153611 width=227) + predicate:(_col1 > _col4) + Map Join Operator [MAPJOIN_213] (rows=460833 width=227) + Conds:SEL_212._col2=RS_210._col0(Inner),Output:["_col0","_col1","_col4"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_210] + PartitionCols:_col0 + Select Operator [SEL_209] (rows=10 width=202) + Output:["_col0","_col1"] + Filter Operator [FIL_208] (rows=10 width=210) + predicate:CAST( (_col1 / _col2) AS decimal(16,6)) is not null + Group By Operator [GBY_207] (rows=10 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_206] PartitionCols:_col0 - Group By Operator [GBY_185] (rows=25 width=4) - Output:["_col0"],keys:d_month_seq - Select Operator [SEL_183] (rows=50 width=12) - Output:["d_month_seq"] - Filter Operator [FIL_181] (rows=50 width=12) - predicate:((d_year = 2000) and (d_moy = 2)) - Please refer to the previous TableScan [TS_3] - <-Select Operator [SEL_198] (rows=80000000 width=8) + Group By Operator [GBY_205] (rows=10 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(i_current_price)","count(i_current_price)"],keys:i_category + Filter Operator [FIL_204] (rows=462000 width=201) + predicate:i_category is not null + TableScan [TS_22] (rows=462000 width=201) + default@item,j,Tbl:COMPLETE,Col:COMPLETE,Output:["i_current_price","i_category"] + <-Select Operator [SEL_212] (rows=460833 width=205) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_211] (rows=460833 width=205) + predicate:(i_current_price is not null and i_category is not null) + TableScan [TS_19] (rows=462000 width=205) + default@item,i,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price","i_category"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_229] + PartitionCols:_col1 + Select Operator [SEL_228] (rows=525327388 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_227] (rows=525327388 width=11) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_65_d_d_date_sk_min) AND DynamicValue(RS_65_d_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_65_d_d_date_sk_bloom_filter))) + TableScan [TS_30] (rows=575995635 width=11) + default@store_sales,s,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk"] + <-Reducer 16 [BROADCAST_EDGE] vectorized + BROADCAST [RS_226] + Group By Operator [GBY_225] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Merge Join Operator [MERGEJOIN_171] (rows=80000000 width=90) + Conds:RS_201._col1=RS_203._col0(Inner),Output:["_col0","_col4"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_201] + PartitionCols:_col1 + Map Join Operator [MAPJOIN_200] (rows=80000000 width=8) + Conds:(Inner),Output:["_col0","_col1"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_197] + Select Operator [SEL_196] (rows=1 width=8) + Filter Operator [FIL_195] (rows=1 width=8) + predicate:(sq_count_check(_col0) <= 1) + Group By Operator [GBY_194] (rows=1 width=8) + Output:["_col0"],aggregations:["count(VALUE._col0)"] + <-Reducer 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_193] + Group By Operator [GBY_192] (rows=1 width=8) + Output:["_col0"],aggregations:["count()"] + Select Operator [SEL_191] (rows=25 width=4) + Group By Operator [GBY_190] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_188] + PartitionCols:_col0 + Group By Operator [GBY_186] (rows=25 width=4) + Output:["_col0"],keys:d_month_seq + Select Operator [SEL_184] (rows=50 width=12) + Output:["d_month_seq"] + Filter Operator [FIL_182] (rows=50 width=12) + predicate:((d_year = 2000) and (d_moy = 2)) + Please refer to the previous TableScan [TS_3] + <-Select Operator [SEL_199] (rows=80000000 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_198] (rows=80000000 width=8) + predicate:c_current_addr_sk is not null + TableScan [TS_0] (rows=80000000 width=8) + default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_203] + PartitionCols:_col0 + Select Operator [SEL_202] (rows=40000000 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_197] (rows=80000000 width=8) - predicate:c_current_addr_sk is not null - TableScan [TS_0] (rows=80000000 width=8) - default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_202] - PartitionCols:_col0 - Select Operator [SEL_201] (rows=40000000 width=90) - Output:["_col0","_col1"] - TableScan [TS_17] (rows=40000000 width=90) - default@customer_address,a,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] + TableScan [TS_17] (rows=40000000 width=90) + default@customer_address,a,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query60.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query60.q.out index 06a5689938..8a4bca1799 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query60.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query60.q.out @@ -197,228 +197,230 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_358] - Limit [LIM_357] (rows=100 width=212) + File Output Operator [FS_364] + Limit [LIM_363] (rows=100 width=212) Number of rows:100 - Select Operator [SEL_356] (rows=1717 width=212) + Select Operator [SEL_362] (rows=1717 width=212) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_355] - Group By Operator [GBY_354] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 11 [CONTAINS] vectorized - Reduce Output Operator [RS_376] - PartitionCols:_col0 - Group By Operator [GBY_375] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Top N Key Operator [TNK_374] (rows=5151 width=212) - keys:_col0,top n:100 - Group By Operator [GBY_373] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col0 - Group By Operator [GBY_105] (rows=99586 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_302] (rows=69268204 width=211) - Conds:RS_101._col0=RS_102._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_101] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_291] (rows=34340 width=104) - Conds:RS_319._col1=RS_325._col0(Inner),Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col1 - Select Operator [SEL_318] (rows=462000 width=104) - Output:["_col0","_col1"] - TableScan [TS_0] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_325] - PartitionCols:_col0 - Group By Operator [GBY_324] (rows=23100 width=100) - Output:["_col0"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Group By Operator [GBY_322] (rows=23100 width=100) - Output:["_col0"],keys:i_item_id - Select Operator [SEL_321] (rows=46200 width=190) - Output:["i_item_id"] - Filter Operator [FIL_320] (rows=46200 width=190) - predicate:(i_category = 'Children') - TableScan [TS_2] (rows=462000 width=190) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_category"] - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_102] - PartitionCols:_col2 - Select Operator [SEL_97] (rows=143931246 width=115) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_299] (rows=143931246 width=115) - Conds:RS_94._col2=RS_349._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_349] - PartitionCols:_col0 - Select Operator [SEL_346] (rows=8000000 width=4) - Output:["_col0"] - Filter Operator [FIL_345] (rows=8000000 width=112) - predicate:(ca_gmt_offset = -6) - TableScan [TS_15] (rows=40000000 width=112) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_94] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_298] (rows=143931246 width=119) - Conds:RS_372._col0=RS_332._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_332] - PartitionCols:_col0 - Select Operator [SEL_327] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_326] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 9)) - TableScan [TS_12] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_372] - PartitionCols:_col0 - Select Operator [SEL_371] (rows=143931246 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_370] (rows=143931246 width=123) - predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_92_date_dim_d_date_sk_min) AND DynamicValue(RS_92_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_92_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_82] (rows=144002668 width=123) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_369] - Group By Operator [GBY_368] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_339] - Group By Operator [GBY_336] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_333] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 4 [CONTAINS] vectorized - Reduce Output Operator [RS_353] - PartitionCols:_col0 - Group By Operator [GBY_352] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Top N Key Operator [TNK_351] (rows=5151 width=212) - keys:_col0,top n:100 - Group By Operator [GBY_350] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col0 - Group By Operator [GBY_32] (rows=343400 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_300] (rows=252818424 width=201) - Conds:RS_28._col0=RS_29._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_28] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_291] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col2 - Select Operator [SEL_24] (rows=525327191 width=110) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_293] (rows=525327191 width=110) - Conds:RS_21._col2=RS_347._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_347] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_292] (rows=525327191 width=114) - Conds:RS_344._col0=RS_328._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_328] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] - PartitionCols:_col0 - Select Operator [SEL_343] (rows=525327191 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_342] (rows=525327191 width=118) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_19_date_dim_d_date_sk_min) AND DynamicValue(RS_19_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_19_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_9] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_341] - Group By Operator [GBY_340] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_337] - Group By Operator [GBY_334] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_329] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_367] - PartitionCols:_col0 - Group By Operator [GBY_366] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Top N Key Operator [TNK_365] (rows=5151 width=212) - keys:_col0,top n:100 - Group By Operator [GBY_364] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_69] - PartitionCols:_col0 - Group By Operator [GBY_68] (rows=195738 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_301] (rows=137215467 width=210) - Conds:RS_64._col0=RS_65._col3(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_64] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_291] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_65] - PartitionCols:_col3 - Select Operator [SEL_60] (rows=285117733 width=115) - Output:["_col3","_col4"] - Merge Join Operator [MERGEJOIN_296] (rows=285117733 width=115) - Conds:RS_57._col1=RS_348._col0(Inner),Output:["_col2","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_57] + SHUFFLE [RS_361] + Top N Key Operator [TNK_360] (rows=1717 width=212) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_359] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 11 [CONTAINS] vectorized + Reduce Output Operator [RS_382] + PartitionCols:_col0 + Group By Operator [GBY_381] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Top N Key Operator [TNK_380] (rows=5151 width=212) + keys:_col0,top n:100 + Group By Operator [GBY_379] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_106] + PartitionCols:_col0 + Group By Operator [GBY_105] (rows=99586 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_307] (rows=69268204 width=211) + Conds:RS_101._col0=RS_102._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_101] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_296] (rows=34340 width=104) + Conds:RS_324._col1=RS_330._col0(Inner),Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_324] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_295] (rows=285117733 width=119) - Conds:RS_363._col0=RS_330._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_330] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_363] + Select Operator [SEL_323] (rows=462000 width=104) + Output:["_col0","_col1"] + TableScan [TS_0] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_330] + PartitionCols:_col0 + Group By Operator [GBY_329] (rows=23100 width=100) + Output:["_col0"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_328] PartitionCols:_col0 - Select Operator [SEL_362] (rows=285117733 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_361] (rows=285117733 width=123) - predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_55_date_dim_d_date_sk_min) AND DynamicValue(RS_55_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_55_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_45] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_360] - Group By Operator [GBY_359] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_338] - Group By Operator [GBY_335] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_331] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] + Group By Operator [GBY_327] (rows=23100 width=100) + Output:["_col0"],keys:i_item_id + Select Operator [SEL_326] (rows=46200 width=190) + Output:["i_item_id"] + Filter Operator [FIL_325] (rows=46200 width=190) + predicate:(i_category = 'Children') + TableScan [TS_2] (rows=462000 width=190) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_category"] + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_102] + PartitionCols:_col2 + Select Operator [SEL_97] (rows=143931246 width=115) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_304] (rows=143931246 width=115) + Conds:RS_94._col2=RS_354._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_354] + PartitionCols:_col0 + Select Operator [SEL_351] (rows=8000000 width=4) + Output:["_col0"] + Filter Operator [FIL_350] (rows=8000000 width=112) + predicate:(ca_gmt_offset = -6) + TableScan [TS_15] (rows=40000000 width=112) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_94] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_303] (rows=143931246 width=119) + Conds:RS_378._col0=RS_337._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_337] + PartitionCols:_col0 + Select Operator [SEL_332] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_331] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 9)) + TableScan [TS_12] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_378] + PartitionCols:_col0 + Select Operator [SEL_377] (rows=143931246 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_376] (rows=143931246 width=123) + predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_92_date_dim_d_date_sk_min) AND DynamicValue(RS_92_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_92_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_82] (rows=144002668 width=123) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_375] + Group By Operator [GBY_374] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_344] + Group By Operator [GBY_341] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_338] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_332] + <-Reducer 4 [CONTAINS] vectorized + Reduce Output Operator [RS_358] + PartitionCols:_col0 + Group By Operator [GBY_357] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Top N Key Operator [TNK_356] (rows=5151 width=212) + keys:_col0,top n:100 + Group By Operator [GBY_355] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col0 + Group By Operator [GBY_32] (rows=343400 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_305] (rows=252818424 width=201) + Conds:RS_28._col0=RS_29._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_28] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_296] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col2 + Select Operator [SEL_24] (rows=525327191 width=110) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_298] (rows=525327191 width=110) + Conds:RS_21._col2=RS_352._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_352] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_351] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_297] (rows=525327191 width=114) + Conds:RS_349._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_333] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_332] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] + PartitionCols:_col0 + Select Operator [SEL_348] (rows=525327191 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_347] (rows=525327191 width=118) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_19_date_dim_d_date_sk_min) AND DynamicValue(RS_19_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_19_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_9] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_346] + Group By Operator [GBY_345] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_342] + Group By Operator [GBY_339] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_334] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_332] + <-Reducer 9 [CONTAINS] vectorized + Reduce Output Operator [RS_373] + PartitionCols:_col0 + Group By Operator [GBY_372] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Top N Key Operator [TNK_371] (rows=5151 width=212) + keys:_col0,top n:100 + Group By Operator [GBY_370] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_69] + PartitionCols:_col0 + Group By Operator [GBY_68] (rows=195738 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_306] (rows=137215467 width=210) + Conds:RS_64._col0=RS_65._col3(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_64] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_296] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_65] + PartitionCols:_col3 + Select Operator [SEL_60] (rows=285117733 width=115) + Output:["_col3","_col4"] + Merge Join Operator [MERGEJOIN_301] (rows=285117733 width=115) + Conds:RS_57._col1=RS_353._col0(Inner),Output:["_col2","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_353] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_351] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_57] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_300] (rows=285117733 width=119) + Conds:RS_369._col0=RS_335._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_335] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_332] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_369] + PartitionCols:_col0 + Select Operator [SEL_368] (rows=285117733 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_367] (rows=285117733 width=123) + predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_55_date_dim_d_date_sk_min) AND DynamicValue(RS_55_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_55_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_45] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 21 [BROADCAST_EDGE] vectorized + BROADCAST [RS_366] + Group By Operator [GBY_365] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_343] + Group By Operator [GBY_340] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_336] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_332] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out index 8d45d8260d..d44f81948d 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query63.q.out @@ -79,73 +79,75 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_81] - Limit [LIM_80] (rows=100 width=228) + File Output Operator [FS_82] + Limit [LIM_81] (rows=100 width=228) Number of rows:100 - Select Operator [SEL_79] (rows=338 width=228) + Select Operator [SEL_80] (rows=338 width=228) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_27] Select Operator [SEL_24] (rows=338 width=228) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_36] (rows=338 width=228) - predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END - Select Operator [SEL_23] (rows=676 width=116) - Output:["avg_window_0","_col0","_col2"] - PTF Operator [PTF_22] (rows=676 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] - Select Operator [SEL_19] (rows=676 width=116) - Output:["_col0","_col2"] - Group By Operator [GBY_18] (rows=676 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0 - Group By Operator [GBY_16] (rows=676 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col4, _col6 - Merge Join Operator [MERGEJOIN_62] (rows=569118 width=8) - Conds:RS_12._col0=RS_76._col0(Inner),Output:["_col2","_col4","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_76] - PartitionCols:_col0 - Select Operator [SEL_75] (rows=317 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_74] (rows=317 width=12) - predicate:(d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_moy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_61] (rows=569118 width=4) - Conds:RS_73._col1=RS_65._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=52 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_63] (rows=52 width=290) - predicate:((i_class) IN ('personal', 'portable', 'refernece', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'refernece', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1')))) - TableScan [TS_3] (rows=462000 width=289) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manager_id"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_73] - PartitionCols:_col1 - Select Operator [SEL_72] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_71] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_70] - Group By Operator [GBY_69] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_68] - Group By Operator [GBY_67] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_66] (rows=52 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_64] + Top N Key Operator [TNK_41] (rows=338 width=228) + keys:_col0, avg_window_0, _col2,top n:100 + Filter Operator [FIL_36] (rows=338 width=228) + predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END + Select Operator [SEL_23] (rows=676 width=116) + Output:["avg_window_0","_col0","_col2"] + PTF Operator [PTF_22] (rows=676 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] + Select Operator [SEL_19] (rows=676 width=116) + Output:["_col0","_col2"] + Group By Operator [GBY_18] (rows=676 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0 + Group By Operator [GBY_16] (rows=676 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col4, _col6 + Merge Join Operator [MERGEJOIN_63] (rows=569118 width=8) + Conds:RS_12._col0=RS_77._col0(Inner),Output:["_col2","_col4","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_77] + PartitionCols:_col0 + Select Operator [SEL_76] (rows=317 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_75] (rows=317 width=12) + predicate:(d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_moy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_62] (rows=569118 width=4) + Conds:RS_74._col1=RS_66._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=52 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_64] (rows=52 width=290) + predicate:((i_class) IN ('personal', 'portable', 'refernece', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'refernece', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1')))) + TableScan [TS_3] (rows=462000 width=289) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manager_id"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_74] + PartitionCols:_col1 + Select Operator [SEL_73] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_72] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_71] + Group By Operator [GBY_70] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_69] + Group By Operator [GBY_68] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_67] (rows=52 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_65] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query65.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query65.q.out index 8b8a4146a6..a117443471 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query65.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query65.q.out @@ -82,101 +82,103 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_164] - Limit [LIM_163] (rows=100 width=708) + File Output Operator [FS_165] + Limit [LIM_164] (rows=100 width=708) Number of rows:100 - Select Operator [SEL_162] (rows=1772841 width=707) + Select Operator [SEL_163] (rows=1772841 width=707) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_51] Select Operator [SEL_50] (rows=1772841 width=707) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_137] (rows=1772841 width=707) - Conds:RS_47._col1=RS_161._col0(Inner),Output:["_col2","_col6","_col8","_col9","_col10","_col11"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_161] - PartitionCols:_col0 - Select Operator [SEL_160] (rows=462000 width=511) - Output:["_col0","_col1","_col2","_col3","_col4"] - TableScan [TS_38] (rows=462000 width=511) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc","i_current_price","i_wholesale_cost","i_brand"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_47] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_136] (rows=1772841 width=204) - Conds:RS_44._col0=RS_159._col0(Inner),Output:["_col1","_col2","_col6"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_159] - PartitionCols:_col0 - Select Operator [SEL_158] (rows=1704 width=92) - Output:["_col0","_col1"] - TableScan [TS_36] (rows=1704 width=92) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_44] - PartitionCols:_col0 - Filter Operator [FIL_43] (rows=1772841 width=231) - predicate:(_col2 <= _col4) - Merge Join Operator [MERGEJOIN_135] (rows=5318523 width=231) - Conds:RS_151._col0=RS_157._col0(Inner),Output:["_col0","_col1","_col2","_col4"] - <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_151] - PartitionCols:_col0 - Filter Operator [FIL_150] (rows=5255208 width=119) - predicate:_col2 is not null - Group By Operator [GBY_149] (rows=5255208 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col0, _col1 - Group By Operator [GBY_10] (rows=525329897 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_133] (rows=525329897 width=114) - Conds:RS_148._col0=RS_140._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_140] - PartitionCols:_col0 - Select Operator [SEL_139] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_138] (rows=317 width=8) - predicate:d_month_seq BETWEEN 1212 AND 1223 - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_146] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_145] - Group By Operator [GBY_144] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_143] - Group By Operator [GBY_142] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_141] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_139] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_157] - PartitionCols:_col0 - Select Operator [SEL_156] (rows=84 width=115) - Output:["_col0","_col1"] - Filter Operator [FIL_155] (rows=84 width=123) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_154] (rows=84 width=123) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 - Select Operator [SEL_153] (rows=5255208 width=119) - Output:["_col1","_col2"] - Group By Operator [GBY_152] (rows=5255208 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col0 - Please refer to the previous Group By Operator [GBY_10] + Top N Key Operator [TNK_80] (rows=1772841 width=707) + keys:_col6, _col8,top n:100 + Merge Join Operator [MERGEJOIN_138] (rows=1772841 width=707) + Conds:RS_47._col1=RS_162._col0(Inner),Output:["_col2","_col6","_col8","_col9","_col10","_col11"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_162] + PartitionCols:_col0 + Select Operator [SEL_161] (rows=462000 width=511) + Output:["_col0","_col1","_col2","_col3","_col4"] + TableScan [TS_38] (rows=462000 width=511) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc","i_current_price","i_wholesale_cost","i_brand"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_47] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_137] (rows=1772841 width=204) + Conds:RS_44._col0=RS_160._col0(Inner),Output:["_col1","_col2","_col6"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_160] + PartitionCols:_col0 + Select Operator [SEL_159] (rows=1704 width=92) + Output:["_col0","_col1"] + TableScan [TS_36] (rows=1704 width=92) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_44] + PartitionCols:_col0 + Filter Operator [FIL_43] (rows=1772841 width=231) + predicate:(_col2 <= _col4) + Merge Join Operator [MERGEJOIN_136] (rows=5318523 width=231) + Conds:RS_152._col0=RS_158._col0(Inner),Output:["_col0","_col1","_col2","_col4"] + <-Reducer 3 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_152] + PartitionCols:_col0 + Filter Operator [FIL_151] (rows=5255208 width=119) + predicate:_col2 is not null + Group By Operator [GBY_150] (rows=5255208 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col0, _col1 + Group By Operator [GBY_10] (rows=525329897 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_134] (rows=525329897 width=114) + Conds:RS_149._col0=RS_141._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_141] + PartitionCols:_col0 + Select Operator [SEL_140] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_139] (rows=317 width=8) + predicate:d_month_seq BETWEEN 1212 AND 1223 + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_147] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_146] + Group By Operator [GBY_145] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_144] + Group By Operator [GBY_143] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_142] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_140] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_158] + PartitionCols:_col0 + Select Operator [SEL_157] (rows=84 width=115) + Output:["_col0","_col1"] + Filter Operator [FIL_156] (rows=84 width=123) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_155] (rows=84 width=123) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 + Select Operator [SEL_154] (rows=5255208 width=119) + Output:["_col1","_col2"] + Group By Operator [GBY_153] (rows=5255208 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col0 + Please refer to the previous Group By Operator [GBY_10] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query66.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query66.q.out index be612609cf..a27a3585d9 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query66.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query66.q.out @@ -479,28 +479,28 @@ Stage-0 limit:-1 Stage-1 Reducer 9 vectorized - File Output Operator [FS_251] - Select Operator [SEL_250] (rows=100 width=4614) + File Output Operator [FS_256] + Select Operator [SEL_255] (rows=100 width=4614) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] - Limit [LIM_249] (rows=100 width=4510) + Limit [LIM_254] (rows=100 width=4510) Number of rows:100 - Select Operator [SEL_248] (rows=2423925 width=4510) + Select Operator [SEL_253] (rows=2423925 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_247] - Group By Operator [GBY_246] (rows=2423925 width=4510) + SHUFFLE [RS_252] + Group By Operator [GBY_251] (rows=2423925 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)","sum(VALUE._col24)","sum(VALUE._col25)","sum(VALUE._col26)","sum(VALUE._col27)","sum(VALUE._col28)","sum(VALUE._col29)","sum(VALUE._col30)","sum(VALUE._col31)","sum(VALUE._col32)","sum(VALUE._col33)","sum(VALUE._col34)","sum(VALUE._col35)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Union 7 [SIMPLE_EDGE] <-Reducer 15 [CONTAINS] vectorized - Reduce Output Operator [RS_261] + Reduce Output Operator [RS_266] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_260] (rows=2513727 width=4510) + Group By Operator [GBY_265] (rows=2513727 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Top N Key Operator [TNK_259] (rows=2513727 width=3166) - keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 - Select Operator [SEL_258] (rows=2513727 width=3166) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] - Group By Operator [GBY_257] (rows=2513700 width=3166) + Select Operator [SEL_264] (rows=2513727 width=3166) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] + Top N Key Operator [TNK_263] (rows=2513727 width=3166) + keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 + Group By Operator [GBY_262] (rows=2513700 width=3166) Output:["_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"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_61] @@ -509,87 +509,87 @@ Stage-0 Output:["_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"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 Select Operator [SEL_58] (rows=15681803 width=750) Output:["_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"] - Merge Join Operator [MERGEJOIN_202] (rows=15681803 width=750) - Conds:RS_55._col3=RS_240._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] + Merge Join Operator [MERGEJOIN_207] (rows=15681803 width=750) + Conds:RS_55._col3=RS_245._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_240] + SHUFFLE [RS_245] PartitionCols:_col0 - Select Operator [SEL_238] (rows=27 width=482) + Select Operator [SEL_243] (rows=27 width=482) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] TableScan [TS_12] (rows=27 width=482) default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name","w_warehouse_sq_ft","w_city","w_county","w_state","w_country"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_55] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_201] (rows=15681803 width=275) - Conds:RS_52._col2=RS_219._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_206] (rows=15681803 width=275) + Conds:RS_52._col2=RS_224._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_219] + SHUFFLE [RS_224] PartitionCols:_col0 - Select Operator [SEL_216] (rows=1 width=4) + Select Operator [SEL_221] (rows=1 width=4) Output:["_col0"] - Filter Operator [FIL_215] (rows=1 width=88) + Filter Operator [FIL_220] (rows=1 width=88) predicate:(sm_carrier) IN ('DIAMOND', 'AIRBORNE') TableScan [TS_9] (rows=1 width=88) default@ship_mode,ship_mode,Tbl:COMPLETE,Col:COMPLETE,Output:["sm_ship_mode_sk","sm_carrier"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_52] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_200] (rows=282272460 width=279) - Conds:RS_49._col0=RS_237._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_205] (rows=282272460 width=279) + Conds:RS_49._col0=RS_242._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_237] + SHUFFLE [RS_242] PartitionCols:_col0 - Select Operator [SEL_235] (rows=652 width=52) + Select Operator [SEL_240] (rows=652 width=52) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - Filter Operator [FIL_234] (rows=652 width=12) + Filter Operator [FIL_239] (rows=652 width=12) predicate:(d_year = 2002) TableScan [TS_6] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_49] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_199] (rows=282272460 width=235) - Conds:RS_256._col1=RS_233._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_204] (rows=282272460 width=235) + Conds:RS_261._col1=RS_238._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_233] + SHUFFLE [RS_238] PartitionCols:_col0 - Select Operator [SEL_231] (rows=33426 width=4) + Select Operator [SEL_236] (rows=33426 width=4) Output:["_col0"] - Filter Operator [FIL_230] (rows=33426 width=8) + Filter Operator [FIL_235] (rows=33426 width=8) predicate:t_time BETWEEN 49530 AND 78330 TableScan [TS_3] (rows=86400 width=8) default@time_dim,time_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["t_time_sk","t_time"] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_256] + SHUFFLE [RS_261] PartitionCols:_col1 - Select Operator [SEL_255] (rows=282272460 width=239) + Select Operator [SEL_260] (rows=282272460 width=239) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_254] (rows=282272460 width=243) + Filter Operator [FIL_259] (rows=282272460 width=243) predicate:(cs_warehouse_sk is not null and cs_sold_date_sk is not null and cs_sold_time_sk is not null and cs_ship_mode_sk is not null and cs_ship_mode_sk BETWEEN DynamicValue(RS_53_ship_mode_sm_ship_mode_sk_min) AND DynamicValue(RS_53_ship_mode_sm_ship_mode_sk_max) and in_bloom_filter(cs_ship_mode_sk, DynamicValue(RS_53_ship_mode_sm_ship_mode_sk_bloom_filter))) TableScan [TS_32] (rows=287989836 width=243) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_sold_time_sk","cs_ship_mode_sk","cs_warehouse_sk","cs_quantity","cs_ext_sales_price","cs_net_paid_inc_ship_tax"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_253] - Group By Operator [GBY_252] (rows=1 width=12) + BROADCAST [RS_258] + Group By Operator [GBY_257] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_224] - Group By Operator [GBY_222] (rows=1 width=12) + SHUFFLE [RS_229] + Group By Operator [GBY_227] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_220] (rows=1 width=4) + Select Operator [SEL_225] (rows=1 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_216] + Please refer to the previous Select Operator [SEL_221] <-Reducer 6 [CONTAINS] vectorized - Reduce Output Operator [RS_245] + Reduce Output Operator [RS_250] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_244] (rows=2513727 width=4510) + Group By Operator [GBY_249] (rows=2513727 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Top N Key Operator [TNK_243] (rows=2513727 width=3166) - keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 - Select Operator [SEL_242] (rows=2513727 width=3166) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] - Group By Operator [GBY_241] (rows=27 width=3166) + Select Operator [SEL_248] (rows=2513727 width=3166) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] + Top N Key Operator [TNK_247] (rows=2513727 width=3166) + keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 + Group By Operator [GBY_246] (rows=27 width=3166) Output:["_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"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_29] @@ -598,57 +598,57 @@ Stage-0 Output:["_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"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 Select Operator [SEL_26] (rows=7992175 width=750) Output:["_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"] - Merge Join Operator [MERGEJOIN_198] (rows=7992175 width=750) - Conds:RS_23._col3=RS_239._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] + Merge Join Operator [MERGEJOIN_203] (rows=7992175 width=750) + Conds:RS_23._col3=RS_244._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] + SHUFFLE [RS_244] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_243] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_197] (rows=7992175 width=275) - Conds:RS_20._col2=RS_217._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_202] (rows=7992175 width=275) + Conds:RS_20._col2=RS_222._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_217] + SHUFFLE [RS_222] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_216] + Please refer to the previous Select Operator [SEL_221] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_196] (rows=143859154 width=279) - Conds:RS_17._col0=RS_236._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_201] (rows=143859154 width=279) + Conds:RS_17._col0=RS_241._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_236] + SHUFFLE [RS_241] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_235] + Please refer to the previous Select Operator [SEL_240] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_195] (rows=143859154 width=235) - Conds:RS_229._col1=RS_232._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_200] (rows=143859154 width=235) + Conds:RS_234._col1=RS_237._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_232] + SHUFFLE [RS_237] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_231] + Please refer to the previous Select Operator [SEL_236] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_229] + SHUFFLE [RS_234] PartitionCols:_col1 - Select Operator [SEL_228] (rows=143859154 width=239) + Select Operator [SEL_233] (rows=143859154 width=239) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_227] (rows=143859154 width=243) + Filter Operator [FIL_232] (rows=143859154 width=243) predicate:(ws_sold_time_sk is not null and ws_warehouse_sk is not null and ws_sold_date_sk is not null and ws_ship_mode_sk is not null and ws_ship_mode_sk BETWEEN DynamicValue(RS_21_ship_mode_sm_ship_mode_sk_min) AND DynamicValue(RS_21_ship_mode_sm_ship_mode_sk_max) and in_bloom_filter(ws_ship_mode_sk, DynamicValue(RS_21_ship_mode_sm_ship_mode_sk_bloom_filter))) TableScan [TS_0] (rows=144002668 width=243) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_sold_time_sk","ws_ship_mode_sk","ws_warehouse_sk","ws_quantity","ws_sales_price","ws_net_paid_inc_tax"] <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_226] - Group By Operator [GBY_225] (rows=1 width=12) + BROADCAST [RS_231] + Group By Operator [GBY_230] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] - Group By Operator [GBY_221] (rows=1 width=12) + SHUFFLE [RS_228] + Group By Operator [GBY_226] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_218] (rows=1 width=4) + Select Operator [SEL_223] (rows=1 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_216] + Please refer to the previous Select Operator [SEL_221] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query67.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query67.q.out index ee1bf12068..9ed7306c46 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query67.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query67.q.out @@ -111,86 +111,88 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_107] - Limit [LIM_106] (rows=100 width=617) + File Output Operator [FS_109] + Limit [LIM_108] (rows=100 width=617) Number of rows:100 - Select Operator [SEL_105] (rows=1575989691 width=617) + Select Operator [SEL_107] (rows=1575989691 width=617) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_104] - Select Operator [SEL_103] (rows=1575989691 width=617) + SHUFFLE [RS_106] + Select Operator [SEL_105] (rows=1575989691 width=617) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Filter Operator [FIL_102] (rows=1575989691 width=613) - predicate:(rank_window_0 <= 100) - PTF Operator [PTF_101] (rows=4727969073 width=613) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col8 DESC NULLS LAST","partition by:":"_col6"}] - Select Operator [SEL_100] (rows=4727969073 width=613) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_99] - PartitionCols:_col6 - Select Operator [SEL_98] (rows=4727969073 width=613) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Group By Operator [GBY_97] (rows=4727969073 width=621) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, KEY._col8 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 - Group By Operator [GBY_20] (rows=4727969073 width=621) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col7, _col9, _col11, _col12, _col13, _col14, 0L - Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=613) - Conds:RS_16._col1=RS_96._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12","_col13","_col14"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] - PartitionCols:_col0 - Select Operator [SEL_95] (rows=462000 width=393) - Output:["_col0","_col1","_col2","_col3","_col4"] - TableScan [TS_8] (rows=462000 width=393) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_16] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_80] (rows=525329897 width=228) - Conds:RS_13._col2=RS_94._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col9"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_94] - PartitionCols:_col0 - Select Operator [SEL_93] (rows=1704 width=104) - Output:["_col0","_col1"] - TableScan [TS_6] (rows=1704 width=104) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_13] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_79] (rows=525329897 width=131) - Conds:RS_92._col0=RS_84._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] - <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_84] - PartitionCols:_col0 - Select Operator [SEL_83] (rows=317 width=16) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_82] (rows=317 width=20) - predicate:d_month_seq BETWEEN 1212 AND 1223 - TableScan [TS_3] (rows=73049 width=20) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_year","d_moy","d_qoy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] - PartitionCols:_col0 - Select Operator [SEL_91] (rows=525329897 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_90] (rows=525329897 width=122) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_11_date_dim_d_date_sk_min) AND DynamicValue(RS_11_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_11_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_quantity","ss_sales_price"] - <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_89] - Group By Operator [GBY_88] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_87] - Group By Operator [GBY_86] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_85] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_83] + Top N Key Operator [TNK_104] (rows=1575989691 width=613) + keys:_col6, _col5, _col4, _col7, _col0, _col2, _col1, _col3, _col8, rank_window_0,top n:100 + Filter Operator [FIL_103] (rows=1575989691 width=613) + predicate:(rank_window_0 <= 100) + PTF Operator [PTF_102] (rows=4727969073 width=613) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col8 DESC NULLS LAST","partition by:":"_col6"}] + Select Operator [SEL_101] (rows=4727969073 width=613) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_100] + PartitionCols:_col6 + Select Operator [SEL_99] (rows=4727969073 width=613) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Group By Operator [GBY_98] (rows=4727969073 width=621) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, KEY._col8 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Group By Operator [GBY_20] (rows=4727969073 width=621) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col7, _col9, _col11, _col12, _col13, _col14, 0L + Merge Join Operator [MERGEJOIN_82] (rows=525329897 width=613) + Conds:RS_16._col1=RS_97._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12","_col13","_col14"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_97] + PartitionCols:_col0 + Select Operator [SEL_96] (rows=462000 width=393) + Output:["_col0","_col1","_col2","_col3","_col4"] + TableScan [TS_8] (rows=462000 width=393) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_16] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=228) + Conds:RS_13._col2=RS_95._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col9"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_95] + PartitionCols:_col0 + Select Operator [SEL_94] (rows=1704 width=104) + Output:["_col0","_col1"] + TableScan [TS_6] (rows=1704 width=104) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_13] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_80] (rows=525329897 width=131) + Conds:RS_93._col0=RS_85._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] + <-Map 8 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_85] + PartitionCols:_col0 + Select Operator [SEL_84] (rows=317 width=16) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_83] (rows=317 width=20) + predicate:d_month_seq BETWEEN 1212 AND 1223 + TableScan [TS_3] (rows=73049 width=20) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_year","d_moy","d_qoy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_93] + PartitionCols:_col0 + Select Operator [SEL_92] (rows=525329897 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_91] (rows=525329897 width=122) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_11_date_dim_d_date_sk_min) AND DynamicValue(RS_11_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_11_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_quantity","ss_sales_price"] + <-Reducer 9 [BROADCAST_EDGE] vectorized + BROADCAST [RS_90] + Group By Operator [GBY_89] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_88] + Group By Operator [GBY_87] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_86] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_84] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query68.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query68.q.out index 97b97ce19d..e07b19540d 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query68.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query68.q.out @@ -113,118 +113,120 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_172] - Limit [LIM_171] (rows=100 width=706) + File Output Operator [FS_173] + Limit [LIM_172] (rows=100 width=706) Number of rows:100 - Select Operator [SEL_170] (rows=457565061 width=706) + Select Operator [SEL_171] (rows=457565061 width=706) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_44] Select Operator [SEL_43] (rows=457565061 width=706) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_42] (rows=457565061 width=706) - predicate:(_col5 <> _col8) - Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=706) - Conds:RS_39._col0=RS_169._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10","_col11"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_39] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_138] (rows=80000000 width=277) - Conds:RS_146._col1=RS_148._col0(Inner),Output:["_col0","_col2","_col3","_col5"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=40000000 width=97) - Output:["_col0","_col1"] - TableScan [TS_3] (rows=40000000 width=97) - default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - PartitionCols:_col1 - Select Operator [SEL_145] (rows=80000000 width=188) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_144] (rows=80000000 width=188) - predicate:c_current_addr_sk is not null - TableScan [TS_0] (rows=80000000 width=188) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] - <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_169] - PartitionCols:_col1 - Select Operator [SEL_168] (rows=457565061 width=436) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_167] (rows=457565061 width=440) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_32] (rows=457565061 width=440) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col1, _col13, _col3, _col5 - Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=425) - Conds:RS_28._col3=RS_149._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col13"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_149] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_147] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_28] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_141] (rows=457565061 width=332) - Conds:RS_25._col2=RS_166._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_166] - PartitionCols:_col0 - Select Operator [SEL_165] (rows=1855 width=4) - Output:["_col0"] - Filter Operator [FIL_164] (rows=1855 width=12) - predicate:((hd_vehicle_count = 1) or (hd_dep_count = 2)) - TableScan [TS_14] (rows=7200 width=12) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_25] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_140] (rows=457565061 width=336) - Conds:RS_22._col4=RS_163._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] - PartitionCols:_col0 - Select Operator [SEL_162] (rows=14 width=4) - Output:["_col0"] - Filter Operator [FIL_161] (rows=14 width=97) - predicate:(s_city) IN ('Cedar Grove', 'Wildwood') - TableScan [TS_11] (rows=1704 width=97) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_139] (rows=457565061 width=340) - Conds:RS_160._col0=RS_152._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_152] - PartitionCols:_col0 - Select Operator [SEL_151] (rows=170 width=4) - Output:["_col0"] - Filter Operator [FIL_150] (rows=170 width=12) - predicate:(d_dom BETWEEN 1 AND 2 and (d_year) IN (1998, 1999, 2000)) - TableScan [TS_8] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dom"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_160] - PartitionCols:_col0 - Select Operator [SEL_159] (rows=457565061 width=343) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_158] (rows=457565061 width=343) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_5] (rows=575995635 width=343) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_ext_sales_price","ss_ext_list_price","ss_ext_tax"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_157] - Group By Operator [GBY_156] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_155] - Group By Operator [GBY_154] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_153] (rows=170 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_151] + Top N Key Operator [TNK_78] (rows=457565061 width=706) + keys:_col3, _col6,top n:100 + Filter Operator [FIL_42] (rows=457565061 width=706) + predicate:(_col5 <> _col8) + Merge Join Operator [MERGEJOIN_144] (rows=457565061 width=706) + Conds:RS_39._col0=RS_170._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10","_col11"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_39] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_139] (rows=80000000 width=277) + Conds:RS_147._col1=RS_149._col0(Inner),Output:["_col0","_col2","_col3","_col5"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=40000000 width=97) + Output:["_col0","_col1"] + TableScan [TS_3] (rows=40000000 width=97) + default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_147] + PartitionCols:_col1 + Select Operator [SEL_146] (rows=80000000 width=188) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_145] (rows=80000000 width=188) + predicate:c_current_addr_sk is not null + TableScan [TS_0] (rows=80000000 width=188) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] + <-Reducer 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_170] + PartitionCols:_col1 + Select Operator [SEL_169] (rows=457565061 width=436) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Group By Operator [GBY_168] (rows=457565061 width=440) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_32] (rows=457565061 width=440) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col1, _col13, _col3, _col5 + Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=425) + Conds:RS_28._col3=RS_150._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col13"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_150] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_148] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_28] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=332) + Conds:RS_25._col2=RS_167._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_167] + PartitionCols:_col0 + Select Operator [SEL_166] (rows=1855 width=4) + Output:["_col0"] + Filter Operator [FIL_165] (rows=1855 width=12) + predicate:((hd_vehicle_count = 1) or (hd_dep_count = 2)) + TableScan [TS_14] (rows=7200 width=12) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_25] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_141] (rows=457565061 width=336) + Conds:RS_22._col4=RS_164._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_164] + PartitionCols:_col0 + Select Operator [SEL_163] (rows=14 width=4) + Output:["_col0"] + Filter Operator [FIL_162] (rows=14 width=97) + predicate:(s_city) IN ('Cedar Grove', 'Wildwood') + TableScan [TS_11] (rows=1704 width=97) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_140] (rows=457565061 width=340) + Conds:RS_161._col0=RS_153._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_153] + PartitionCols:_col0 + Select Operator [SEL_152] (rows=170 width=4) + Output:["_col0"] + Filter Operator [FIL_151] (rows=170 width=12) + predicate:(d_dom BETWEEN 1 AND 2 and (d_year) IN (1998, 1999, 2000)) + TableScan [TS_8] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dom"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_161] + PartitionCols:_col0 + Select Operator [SEL_160] (rows=457565061 width=343) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_159] (rows=457565061 width=343) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_5] (rows=575995635 width=343) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_ext_sales_price","ss_ext_list_price","ss_ext_tax"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_158] + Group By Operator [GBY_157] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_156] + Group By Operator [GBY_155] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_154] (rows=170 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_152] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query69.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query69.q.out index d7469ae5a9..57d36f5063 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query69.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query69.q.out @@ -133,30 +133,30 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_229] - Limit [LIM_228] (rows=1 width=383) + File Output Operator [FS_234] + Limit [LIM_233] (rows=1 width=383) Number of rows:100 - Select Operator [SEL_227] (rows=1 width=383) + Select Operator [SEL_232] (rows=1 width=383) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_226] - Select Operator [SEL_225] (rows=1 width=383) + SHUFFLE [RS_231] + Select Operator [SEL_230] (rows=1 width=383) Output:["_col0","_col1","_col2","_col3","_col4","_col6"] - Group By Operator [GBY_224] (rows=1 width=367) + Group By Operator [GBY_229] (rows=1 width=367) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_68] PartitionCols:_col0, _col1, _col2, _col3, _col4 Group By Operator [GBY_67] (rows=1 width=367) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count()"],keys:_col6, _col7, _col8, _col9, _col10 - Top N Key Operator [TNK_104] (rows=1 width=363) - keys:_col6, _col7, _col8, _col9, _col10,top n:100 - Select Operator [SEL_66] (rows=1 width=363) - Output:["_col6","_col7","_col8","_col9","_col10"] + Select Operator [SEL_66] (rows=1 width=363) + Output:["_col6","_col7","_col8","_col9","_col10"] + Top N Key Operator [TNK_107] (rows=1 width=363) + keys:_col6, _col7, _col8, _col9, _col10,top n:100 Filter Operator [FIL_65] (rows=1 width=363) predicate:_col13 is null - Merge Join Operator [MERGEJOIN_183] (rows=1401496 width=363) - Conds:RS_62._col0=RS_223._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col13"] + Merge Join Operator [MERGEJOIN_188] (rows=1401496 width=363) + Conds:RS_62._col0=RS_228._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col13"] <-Reducer 5 [SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_62] PartitionCols:_col0 @@ -164,55 +164,55 @@ Stage-0 Output:["_col0","_col6","_col7","_col8","_col9","_col10"] Filter Operator [FIL_46] (rows=1 width=367) predicate:_col11 is null - Merge Join Operator [MERGEJOIN_182] (rows=1414922 width=367) - Conds:RS_43._col0=RS_215._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11"] + Merge Join Operator [MERGEJOIN_187] (rows=1414922 width=367) + Conds:RS_43._col0=RS_220._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11"] <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_215] + SHUFFLE [RS_220] PartitionCols:_col1 - Select Operator [SEL_214] (rows=1414922 width=7) + Select Operator [SEL_219] (rows=1414922 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_213] (rows=1414922 width=3) + Group By Operator [GBY_218] (rows=1414922 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 Group By Operator [GBY_28] (rows=143930993 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_179] (rows=143930993 width=3) - Conds:RS_212._col0=RS_196._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_184] (rows=143930993 width=3) + Conds:RS_217._col0=RS_201._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_196] + SHUFFLE [RS_201] PartitionCols:_col0 - Select Operator [SEL_193] (rows=150 width=4) + Select Operator [SEL_198] (rows=150 width=4) Output:["_col0"] - Filter Operator [FIL_192] (rows=150 width=12) + Filter Operator [FIL_197] (rows=150 width=12) predicate:((d_year = 1999) and d_moy BETWEEN 1 AND 3) TableScan [TS_11] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_212] + SHUFFLE [RS_217] PartitionCols:_col0 - Select Operator [SEL_211] (rows=143930993 width=7) + Select Operator [SEL_216] (rows=143930993 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_210] (rows=143930993 width=7) + Filter Operator [FIL_215] (rows=143930993 width=7) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_25_date_dim_d_date_sk_min) AND DynamicValue(RS_25_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_25_date_dim_d_date_sk_bloom_filter))) TableScan [TS_18] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"] <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_209] - Group By Operator [GBY_208] (rows=1 width=12) + BROADCAST [RS_214] + Group By Operator [GBY_213] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_202] - Group By Operator [GBY_200] (rows=1 width=12) + SHUFFLE [RS_207] + Group By Operator [GBY_205] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_197] (rows=150 width=4) + Select Operator [SEL_202] (rows=150 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_43] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_181] (rows=525327388 width=363) + Merge Join Operator [MERGEJOIN_186] (rows=525327388 width=363) Conds:RS_40._col0=RS_41._col0(Left Semi),Output:["_col0","_col6","_col7","_col8","_col9","_col10"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_41] @@ -221,103 +221,103 @@ Stage-0 Output:["_col0"],keys:_col0 Select Operator [SEL_17] (rows=525327388 width=3) Output:["_col0"] - Merge Join Operator [MERGEJOIN_178] (rows=525327388 width=3) - Conds:RS_207._col0=RS_194._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_183] (rows=525327388 width=3) + Conds:RS_212._col0=RS_199._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_194] + SHUFFLE [RS_199] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_207] + SHUFFLE [RS_212] PartitionCols:_col0 - Select Operator [SEL_206] (rows=525327388 width=7) + Select Operator [SEL_211] (rows=525327388 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_205] (rows=525327388 width=7) + Filter Operator [FIL_210] (rows=525327388 width=7) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) TableScan [TS_8] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_204] - Group By Operator [GBY_203] (rows=1 width=12) + BROADCAST [RS_209] + Group By Operator [GBY_208] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - Group By Operator [GBY_199] (rows=1 width=12) + SHUFFLE [RS_206] + Group By Operator [GBY_204] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_195] (rows=150 width=4) + Select Operator [SEL_200] (rows=150 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_40] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_177] (rows=4605476 width=363) - Conds:RS_35._col1=RS_191._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10"] + Merge Join Operator [MERGEJOIN_182] (rows=4605476 width=363) + Conds:RS_35._col1=RS_196._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] + SHUFFLE [RS_196] PartitionCols:_col0 - Select Operator [SEL_190] (rows=1861800 width=363) + Select Operator [SEL_195] (rows=1861800 width=363) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] TableScan [TS_6] (rows=1861800 width=363) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status","cd_purchase_estimate","cd_credit_rating"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_35] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_176] (rows=4541258 width=5) - Conds:RS_186._col2=RS_189._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_181] (rows=4541258 width=5) + Conds:RS_191._col2=RS_194._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_186] + SHUFFLE [RS_191] PartitionCols:_col2 - Select Operator [SEL_185] (rows=77201384 width=11) + Select Operator [SEL_190] (rows=77201384 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_184] (rows=77201384 width=11) + Filter Operator [FIL_189] (rows=77201384 width=11) predicate:(c_current_cdemo_sk is not null and c_current_addr_sk is not null) TableScan [TS_0] (rows=80000000 width=11) default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_189] + SHUFFLE [RS_194] PartitionCols:_col0 - Select Operator [SEL_188] (rows=2352941 width=90) + Select Operator [SEL_193] (rows=2352941 width=90) Output:["_col0"] - Filter Operator [FIL_187] (rows=2352941 width=90) + Filter Operator [FIL_192] (rows=2352941 width=90) predicate:(ca_state) IN ('CO', 'IL', 'MN') TableScan [TS_3] (rows=40000000 width=90) default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] + SHUFFLE [RS_228] PartitionCols:_col1 - Select Operator [SEL_222] (rows=1401496 width=7) + Select Operator [SEL_227] (rows=1401496 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_221] (rows=1401496 width=3) + Group By Operator [GBY_226] (rows=1401496 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_59] PartitionCols:_col0 Group By Operator [GBY_58] (rows=285115246 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_180] (rows=285115246 width=3) - Conds:RS_220._col0=RS_198._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_185] (rows=285115246 width=3) + Conds:RS_225._col0=RS_203._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] + SHUFFLE [RS_203] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_220] + SHUFFLE [RS_225] PartitionCols:_col0 - Select Operator [SEL_219] (rows=285115246 width=7) + Select Operator [SEL_224] (rows=285115246 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_218] (rows=285115246 width=7) + Filter Operator [FIL_223] (rows=285115246 width=7) predicate:(cs_ship_customer_sk is not null and cs_sold_date_sk is not null and cs_ship_customer_sk BETWEEN DynamicValue(RS_62_c_c_customer_sk_min) AND DynamicValue(RS_62_c_c_customer_sk_max) and in_bloom_filter(cs_ship_customer_sk, DynamicValue(RS_62_c_c_customer_sk_bloom_filter))) TableScan [TS_48] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_217] - Group By Operator [GBY_216] (rows=1 width=12) + BROADCAST [RS_222] + Group By Operator [GBY_221] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Reducer 5 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_167] - Group By Operator [GBY_166] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_172] + Group By Operator [GBY_171] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_165] (rows=1 width=4) + Select Operator [SEL_170] (rows=1 width=4) Output:["_col0"] Please refer to the previous Select Operator [SEL_47] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query7.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query7.q.out index b2eccdbe90..7dc1bf6c3e 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query7.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query7.q.out @@ -67,93 +67,93 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_123] - Limit [LIM_122] (rows=100 width=444) + File Output Operator [FS_128] + Limit [LIM_127] (rows=100 width=444) Number of rows:100 - Select Operator [SEL_121] (rows=310774 width=444) + Select Operator [SEL_126] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_120] - Select Operator [SEL_119] (rows=310774 width=444) + SHUFFLE [RS_125] + Select Operator [SEL_124] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_118] (rows=310774 width=476) + Group By Operator [GBY_123] (rows=310774 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)"],keys:KEY._col0 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col0 Group By Operator [GBY_27] (rows=462000 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col4)","count(_col4)","sum(_col5)","count(_col5)","sum(_col7)","count(_col7)","sum(_col6)","count(_col6)"],keys:_col12 - Top N Key Operator [TNK_54] (rows=4635977 width=100) + Top N Key Operator [TNK_57] (rows=4635977 width=100) keys:_col12,top n:100 - Merge Join Operator [MERGEJOIN_98] (rows=4635977 width=100) - Conds:RS_23._col1=RS_117._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] + Merge Join Operator [MERGEJOIN_103] (rows=4635977 width=100) + Conds:RS_23._col1=RS_122._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] + SHUFFLE [RS_122] PartitionCols:_col0 - Select Operator [SEL_116] (rows=462000 width=104) + Select Operator [SEL_121] (rows=462000 width=104) Output:["_col0","_col1"] TableScan [TS_12] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_97] (rows=4635977 width=4) - Conds:RS_20._col3=RS_115._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_102] (rows=4635977 width=4) + Conds:RS_20._col3=RS_120._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_115] + SHUFFLE [RS_120] PartitionCols:_col0 - Select Operator [SEL_114] (rows=2300 width=4) + Select Operator [SEL_119] (rows=2300 width=4) Output:["_col0"] - Filter Operator [FIL_113] (rows=2300 width=174) + Filter Operator [FIL_118] (rows=2300 width=174) predicate:((p_channel_email = 'N') or (p_channel_event = 'N')) TableScan [TS_9] (rows=2300 width=174) default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_email","p_channel_event"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_96] (rows=4635977 width=4) - Conds:RS_17._col0=RS_112._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_101] (rows=4635977 width=4) + Conds:RS_17._col0=RS_117._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_112] + SHUFFLE [RS_117] PartitionCols:_col0 - Select Operator [SEL_111] (rows=652 width=4) + Select Operator [SEL_116] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_110] (rows=652 width=8) + Filter Operator [FIL_115] (rows=652 width=8) predicate:(d_year = 1998) TableScan [TS_6] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_95] (rows=4635977 width=4) - Conds:RS_109._col2=RS_101._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_100] (rows=4635977 width=4) + Conds:RS_114._col2=RS_106._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_101] + PARTITION_ONLY_SHUFFLE [RS_106] PartitionCols:_col0 - Select Operator [SEL_100] (rows=14776 width=4) + Select Operator [SEL_105] (rows=14776 width=4) Output:["_col0"] - Filter Operator [FIL_99] (rows=14776 width=268) + Filter Operator [FIL_104] (rows=14776 width=268) predicate:((cd_marital_status = 'W') and (cd_education_status = 'Primary') and (cd_gender = 'F')) TableScan [TS_3] (rows=1861800 width=268) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_109] + SHUFFLE [RS_114] PartitionCols:_col2 - Select Operator [SEL_108] (rows=501686735 width=340) + Select Operator [SEL_113] (rows=501686735 width=340) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_107] (rows=501686735 width=340) + Filter Operator [FIL_112] (rows=501686735 width=340) predicate:(ss_cdemo_sk is not null and ss_sold_date_sk is not null and ss_promo_sk is not null and ss_cdemo_sk BETWEEN DynamicValue(RS_15_customer_demographics_cd_demo_sk_min) AND DynamicValue(RS_15_customer_demographics_cd_demo_sk_max) and in_bloom_filter(ss_cdemo_sk, DynamicValue(RS_15_customer_demographics_cd_demo_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=340) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_cdemo_sk","ss_promo_sk","ss_quantity","ss_list_price","ss_sales_price","ss_coupon_amt"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_106] - Group By Operator [GBY_105] (rows=1 width=12) + BROADCAST [RS_111] + Group By Operator [GBY_110] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_104] - Group By Operator [GBY_103] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_109] + Group By Operator [GBY_108] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_102] (rows=14776 width=4) + Select Operator [SEL_107] (rows=14776 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_100] + Please refer to the previous Select Operator [SEL_105] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query70.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query70.q.out index d5efae9aeb..40dfaa2f13 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query70.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query70.q.out @@ -100,117 +100,119 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_170] - Limit [LIM_169] (rows=100 width=492) + File Output Operator [FS_172] + Limit [LIM_171] (rows=100 width=492) Number of rows:100 - Select Operator [SEL_168] (rows=720 width=492) + Select Operator [SEL_170] (rows=720 width=492) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_167] - Select Operator [SEL_166] (rows=720 width=492) + SHUFFLE [RS_169] + Select Operator [SEL_168] (rows=720 width=492) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_165] (rows=720 width=304) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] - Select Operator [SEL_164] (rows=720 width=304) - Output:["_col0","_col1","_col2","_col3"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] - PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END - Select Operator [SEL_162] (rows=720 width=304) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_161] (rows=720 width=304) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_50] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_49] (rows=430560 width=304) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L - Select Operator [SEL_47] (rows=525329897 width=290) - Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_136] (rows=525329897 width=290) - Conds:RS_44._col1=RS_45._col0(Inner),Output:["_col2","_col6","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_44] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_132] (rows=525329897 width=110) - Conds:RS_147._col0=RS_139._col0(Inner),Output:["_col1","_col2"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_139] - PartitionCols:_col0 - Select Operator [SEL_138] (rows=317 width=8) - Output:["_col0"] - Filter Operator [FIL_137] (rows=317 width=8) - predicate:d_month_seq BETWEEN 1212 AND 1223 - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_147] - PartitionCols:_col0 - Select Operator [SEL_146] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_145] (rows=525329897 width=114) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_42_d1_d_date_sk_min) AND DynamicValue(RS_42_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_42_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_net_profit"] - <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_144] - Group By Operator [GBY_143] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_142] - Group By Operator [GBY_141] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_140] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_138] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_135] (rows=556 width=188) - Conds:RS_160._col2=RS_157._col0(Inner),Output:["_col0","_col1","_col2"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_160] - PartitionCols:_col2 - Select Operator [SEL_159] (rows=1704 width=188) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_158] (rows=1704 width=188) - predicate:s_state is not null - TableScan [TS_6] (rows=1704 width=188) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_county","s_state"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_157] - PartitionCols:_col0 - Select Operator [SEL_156] (rows=16 width=86) - Output:["_col0"] - Filter Operator [FIL_155] (rows=16 width=198) - predicate:(rank_window_0 <= 5) - PTF Operator [PTF_154] (rows=49 width=198) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"_col0"}] - Select Operator [SEL_153] (rows=49 width=198) - Output:["_col0","_col1"] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_152] - PartitionCols:_col0 - Group By Operator [GBY_151] (rows=49 width=198) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_26] - PartitionCols:_col0 - Group By Operator [GBY_25] (rows=19404 width=198) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col5 - Merge Join Operator [MERGEJOIN_134] (rows=525329897 width=192) - Conds:RS_21._col1=RS_150._col0(Inner),Output:["_col2","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col1 - Please refer to the previous Merge Join Operator [MERGEJOIN_132] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_150] - PartitionCols:_col0 - Select Operator [SEL_149] (rows=1704 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_148] (rows=1704 width=90) - predicate:s_state is not null - TableScan [TS_15] (rows=1704 width=90) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] + Top N Key Operator [TNK_167] (rows=720 width=304) + keys:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN (((grouping(_col3, 1L) + grouping(_col3, 0L)) = 0L)) THEN (_col0) ELSE (null) END, rank_window_0,top n:100 + PTF Operator [PTF_166] (rows=720 width=304) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] + Select Operator [SEL_165] (rows=720 width=304) + Output:["_col0","_col1","_col2","_col3"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_164] + PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END + Select Operator [SEL_163] (rows=720 width=304) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_162] (rows=720 width=304) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_50] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_49] (rows=430560 width=304) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L + Select Operator [SEL_47] (rows=525329897 width=290) + Output:["_col0","_col1","_col2"] + Merge Join Operator [MERGEJOIN_137] (rows=525329897 width=290) + Conds:RS_44._col1=RS_45._col0(Inner),Output:["_col2","_col6","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_44] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_133] (rows=525329897 width=110) + Conds:RS_148._col0=RS_140._col0(Inner),Output:["_col1","_col2"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_140] + PartitionCols:_col0 + Select Operator [SEL_139] (rows=317 width=8) + Output:["_col0"] + Filter Operator [FIL_138] (rows=317 width=8) + predicate:d_month_seq BETWEEN 1212 AND 1223 + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_148] + PartitionCols:_col0 + Select Operator [SEL_147] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_146] (rows=525329897 width=114) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_42_d1_d_date_sk_min) AND DynamicValue(RS_42_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_42_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_net_profit"] + <-Reducer 12 [BROADCAST_EDGE] vectorized + BROADCAST [RS_145] + Group By Operator [GBY_144] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_143] + Group By Operator [GBY_142] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_141] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_139] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_45] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_136] (rows=556 width=188) + Conds:RS_161._col2=RS_158._col0(Inner),Output:["_col0","_col1","_col2"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_161] + PartitionCols:_col2 + Select Operator [SEL_160] (rows=1704 width=188) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_159] (rows=1704 width=188) + predicate:s_state is not null + TableScan [TS_6] (rows=1704 width=188) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_county","s_state"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_158] + PartitionCols:_col0 + Select Operator [SEL_157] (rows=16 width=86) + Output:["_col0"] + Filter Operator [FIL_156] (rows=16 width=198) + predicate:(rank_window_0 <= 5) + PTF Operator [PTF_155] (rows=49 width=198) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"_col0"}] + Select Operator [SEL_154] (rows=49 width=198) + Output:["_col0","_col1"] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_153] + PartitionCols:_col0 + Group By Operator [GBY_152] (rows=49 width=198) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_26] + PartitionCols:_col0 + Group By Operator [GBY_25] (rows=19404 width=198) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col5 + Merge Join Operator [MERGEJOIN_135] (rows=525329897 width=192) + Conds:RS_21._col1=RS_151._col0(Inner),Output:["_col2","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col1 + Please refer to the previous Merge Join Operator [MERGEJOIN_133] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_151] + PartitionCols:_col0 + Select Operator [SEL_150] (rows=1704 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_149] (rows=1704 width=90) + predicate:s_state is not null + TableScan [TS_15] (rows=1704 width=90) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query72.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query72.q.out index 9d6a3f6a00..50a651aaae 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query72.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query72.q.out @@ -101,175 +101,177 @@ Stage-0 limit:100 Stage-1 Reducer 12 vectorized - File Output Operator [FS_283] - Limit [LIM_282] (rows=100 width=312) + File Output Operator [FS_285] + Limit [LIM_284] (rows=100 width=312) Number of rows:100 - Select Operator [SEL_281] (rows=2645646117 width=312) + Select Operator [SEL_283] (rows=2645646117 width=312) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_280] - Group By Operator [GBY_279] (rows=2645646117 width=312) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)","count(VALUE._col1)","count(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_65] (rows=2645646117 width=312) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(_col3)","count(_col4)","count()"],keys:_col0, _col1, _col2 - Select Operator [SEL_63] (rows=6823092784 width=292) - Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_247] (rows=6823092784 width=292) - Conds:RS_60._col4, _col6=RS_278._col0, _col1(Left Outer),Output:["_col13","_col15","_col19","_col25"] - <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_278] - PartitionCols:_col0, _col1 - Select Operator [SEL_277] (rows=28798881 width=8) - Output:["_col0","_col1"] - TableScan [TS_58] (rows=28798881 width=8) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_60] - PartitionCols:_col4, _col6 - Select Operator [SEL_57] (rows=2645646117 width=300) - Output:["_col4","_col6","_col13","_col15","_col19","_col25"] - Merge Join Operator [MERGEJOIN_246] (rows=2645646117 width=300) - Conds:RS_54._col4=RS_276._col0(Inner),Output:["_col4","_col6","_col13","_col20","_col21","_col25"] - <-Map 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_276] - PartitionCols:_col0 - Select Operator [SEL_275] (rows=462000 width=188) - Output:["_col0","_col1"] - TableScan [TS_29] (rows=462000 width=188) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_54] - PartitionCols:_col4 - Filter Operator [FIL_53] (rows=2645646117 width=132) - predicate:(_col23 > _col14) - Merge Join Operator [MERGEJOIN_245] (rows=7936938353 width=132) - Conds:RS_50._col1=RS_274._col0(Inner),Output:["_col4","_col6","_col13","_col14","_col20","_col21","_col23"] - <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_274] - PartitionCols:_col0 - Select Operator [SEL_273] (rows=73049 width=12) - Output:["_col0","_col1"] - Filter Operator [FIL_272] (rows=73049 width=98) - predicate:UDFToDouble(d_date) is not null - TableScan [TS_26] (rows=73049 width=98) - default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_50] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_244] (rows=7936938353 width=127) - Conds:RS_47._col5=RS_271._col0(Left Outer),Output:["_col1","_col4","_col6","_col13","_col14","_col20","_col21"] - <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_271] - PartitionCols:_col0 - Select Operator [SEL_270] (rows=2300 width=4) - Output:["_col0"] - TableScan [TS_24] (rows=2300 width=4) - default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_47] - PartitionCols:_col5 - Merge Join Operator [MERGEJOIN_243] (rows=7936938353 width=127) - Conds:RS_44._col17=RS_269._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col13","_col14","_col20"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_269] - PartitionCols:_col0 - Select Operator [SEL_268] (rows=27 width=104) - Output:["_col0","_col1"] - TableScan [TS_22] (rows=27 width=104) - default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_44] - PartitionCols:_col17 - Filter Operator [FIL_43] (rows=7936938353 width=39) - predicate:(_col18 < _col7) - Merge Join Operator [MERGEJOIN_242] (rows=23810815059 width=39) - Conds:RS_40._col10, _col4=RS_267._col0, _col1(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col13","_col14","_col17","_col18"] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_267] - PartitionCols:_col0, _col1 - Select Operator [SEL_266] (rows=35703276 width=15) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_265] (rows=35703276 width=15) - predicate:inv_quantity_on_hand is not null - TableScan [TS_19] (rows=37584000 width=15) - default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col10, _col4 - Merge Join Operator [MERGEJOIN_241] (rows=41723124 width=35) - Conds:RS_37._col0=RS_38._col2(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col10","_col13","_col14"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_38] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_240] (rows=3621 width=20) - Conds:RS_250._col1=RS_253._col1(Inner),Output:["_col0","_col2","_col3","_col4"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_250] - PartitionCols:_col1 - Select Operator [SEL_249] (rows=73049 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_248] (rows=73049 width=8) - predicate:d_week_seq is not null - TableScan [TS_9] (rows=73049 width=8) - default@date_dim,d2,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq"] - <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_253] - PartitionCols:_col1 - Select Operator [SEL_252] (rows=652 width=16) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_251] (rows=652 width=106) - predicate:((d_year = 2001) and d_week_seq is not null and UDFToDouble(d_date) is not null) - TableScan [TS_12] (rows=73049 width=106) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_week_seq","d_year"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_239] (rows=41723124 width=23) - Conds:RS_34._col3=RS_264._col0(Inner),Output:["_col0","_col1","_col4","_col5","_col6","_col7"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_264] - PartitionCols:_col0 - Select Operator [SEL_263] (rows=1440 width=4) - Output:["_col0"] - Filter Operator [FIL_262] (rows=1440 width=96) - predicate:(hd_buy_potential = '1001-5000') - TableScan [TS_6] (rows=7200 width=96) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_buy_potential"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_238] (rows=41723124 width=27) - Conds:RS_258._col2=RS_261._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_258] - PartitionCols:_col2 - Select Operator [SEL_257] (rows=280863798 width=31) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_256] (rows=280863798 width=31) - predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_ship_date_sk is not null and cs_quantity is not null and cs_bill_hdemo_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_38_d1_d_date_sk_min) AND DynamicValue(RS_38_d1_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_38_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=287989836 width=31) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_bill_cdemo_sk","cs_bill_hdemo_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_quantity"] - <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_255] - Group By Operator [GBY_254] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 16 [CUSTOM_SIMPLE_EDGE] - SHUFFLE [RS_142] - Group By Operator [GBY_141] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_140] (rows=3621 width=8) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_240] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_261] - PartitionCols:_col0 - Select Operator [SEL_260] (rows=265971 width=4) - Output:["_col0"] - Filter Operator [FIL_259] (rows=265971 width=89) - predicate:(cd_marital_status = 'M') - TableScan [TS_3] (rows=1861800 width=89) - default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status"] + SHUFFLE [RS_282] + Top N Key Operator [TNK_281] (rows=2645646117 width=312) + keys:_col5, _col0, _col1, _col2,top n:100 + Group By Operator [GBY_280] (rows=2645646117 width=312) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)","count(VALUE._col1)","count(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_65] (rows=2645646117 width=312) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(_col3)","count(_col4)","count()"],keys:_col0, _col1, _col2 + Select Operator [SEL_63] (rows=6823092784 width=292) + Output:["_col0","_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_248] (rows=6823092784 width=292) + Conds:RS_60._col4, _col6=RS_279._col0, _col1(Left Outer),Output:["_col13","_col15","_col19","_col25"] + <-Map 24 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_279] + PartitionCols:_col0, _col1 + Select Operator [SEL_278] (rows=28798881 width=8) + Output:["_col0","_col1"] + TableScan [TS_58] (rows=28798881 width=8) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_60] + PartitionCols:_col4, _col6 + Select Operator [SEL_57] (rows=2645646117 width=300) + Output:["_col4","_col6","_col13","_col15","_col19","_col25"] + Merge Join Operator [MERGEJOIN_247] (rows=2645646117 width=300) + Conds:RS_54._col4=RS_277._col0(Inner),Output:["_col4","_col6","_col13","_col20","_col21","_col25"] + <-Map 23 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_277] + PartitionCols:_col0 + Select Operator [SEL_276] (rows=462000 width=188) + Output:["_col0","_col1"] + TableScan [TS_29] (rows=462000 width=188) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_54] + PartitionCols:_col4 + Filter Operator [FIL_53] (rows=2645646117 width=132) + predicate:(_col23 > _col14) + Merge Join Operator [MERGEJOIN_246] (rows=7936938353 width=132) + Conds:RS_50._col1=RS_275._col0(Inner),Output:["_col4","_col6","_col13","_col14","_col20","_col21","_col23"] + <-Map 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_275] + PartitionCols:_col0 + Select Operator [SEL_274] (rows=73049 width=12) + Output:["_col0","_col1"] + Filter Operator [FIL_273] (rows=73049 width=98) + predicate:UDFToDouble(d_date) is not null + TableScan [TS_26] (rows=73049 width=98) + default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_50] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_245] (rows=7936938353 width=127) + Conds:RS_47._col5=RS_272._col0(Left Outer),Output:["_col1","_col4","_col6","_col13","_col14","_col20","_col21"] + <-Map 21 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_272] + PartitionCols:_col0 + Select Operator [SEL_271] (rows=2300 width=4) + Output:["_col0"] + TableScan [TS_24] (rows=2300 width=4) + default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk"] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_47] + PartitionCols:_col5 + Merge Join Operator [MERGEJOIN_244] (rows=7936938353 width=127) + Conds:RS_44._col17=RS_270._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col13","_col14","_col20"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_270] + PartitionCols:_col0 + Select Operator [SEL_269] (rows=27 width=104) + Output:["_col0","_col1"] + TableScan [TS_22] (rows=27 width=104) + default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_44] + PartitionCols:_col17 + Filter Operator [FIL_43] (rows=7936938353 width=39) + predicate:(_col18 < _col7) + Merge Join Operator [MERGEJOIN_243] (rows=23810815059 width=39) + Conds:RS_40._col10, _col4=RS_268._col0, _col1(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col13","_col14","_col17","_col18"] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_268] + PartitionCols:_col0, _col1 + Select Operator [SEL_267] (rows=35703276 width=15) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_266] (rows=35703276 width=15) + predicate:inv_quantity_on_hand is not null + TableScan [TS_19] (rows=37584000 width=15) + default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col10, _col4 + Merge Join Operator [MERGEJOIN_242] (rows=41723124 width=35) + Conds:RS_37._col0=RS_38._col2(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col10","_col13","_col14"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_38] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_241] (rows=3621 width=20) + Conds:RS_251._col1=RS_254._col1(Inner),Output:["_col0","_col2","_col3","_col4"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_251] + PartitionCols:_col1 + Select Operator [SEL_250] (rows=73049 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_249] (rows=73049 width=8) + predicate:d_week_seq is not null + TableScan [TS_9] (rows=73049 width=8) + default@date_dim,d2,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq"] + <-Map 18 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_254] + PartitionCols:_col1 + Select Operator [SEL_253] (rows=652 width=16) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_252] (rows=652 width=106) + predicate:((d_year = 2001) and d_week_seq is not null and UDFToDouble(d_date) is not null) + TableScan [TS_12] (rows=73049 width=106) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_week_seq","d_year"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_240] (rows=41723124 width=23) + Conds:RS_34._col3=RS_265._col0(Inner),Output:["_col0","_col1","_col4","_col5","_col6","_col7"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_265] + PartitionCols:_col0 + Select Operator [SEL_264] (rows=1440 width=4) + Output:["_col0"] + Filter Operator [FIL_263] (rows=1440 width=96) + predicate:(hd_buy_potential = '1001-5000') + TableScan [TS_6] (rows=7200 width=96) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_buy_potential"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_239] (rows=41723124 width=27) + Conds:RS_259._col2=RS_262._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_259] + PartitionCols:_col2 + Select Operator [SEL_258] (rows=280863798 width=31) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_257] (rows=280863798 width=31) + predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_ship_date_sk is not null and cs_quantity is not null and cs_bill_hdemo_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_38_d1_d_date_sk_min) AND DynamicValue(RS_38_d1_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_38_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=287989836 width=31) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_bill_cdemo_sk","cs_bill_hdemo_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_quantity"] + <-Reducer 17 [BROADCAST_EDGE] vectorized + BROADCAST [RS_256] + Group By Operator [GBY_255] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 16 [CUSTOM_SIMPLE_EDGE] + SHUFFLE [RS_143] + Group By Operator [GBY_142] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_141] (rows=3621 width=8) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_241] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_262] + PartitionCols:_col0 + Select Operator [SEL_261] (rows=265971 width=4) + Output:["_col0"] + Filter Operator [FIL_260] (rows=265971 width=89) + predicate:(cd_marital_status = 'M') + TableScan [TS_3] (rows=1861800 width=89) + default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query74.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query74.q.out index 68ff9ebf26..62b03db7ff 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query74.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query74.q.out @@ -161,237 +161,239 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_348] - Limit [LIM_347] (rows=100 width=280) + File Output Operator [FS_349] + Limit [LIM_348] (rows=100 width=280) Number of rows:100 - Select Operator [SEL_346] (rows=19066162 width=280) + Select Operator [SEL_347] (rows=19066162 width=280) Output:["_col0","_col1","_col2"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_89] Select Operator [SEL_88] (rows=19066162 width=280) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_87] (rows=19066162 width=732) - predicate:CASE WHEN (_col4 is not null) THEN (CASE WHEN (_col2) THEN (((_col6 / _col1) > (_col10 / _col4))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_283] (rows=38132324 width=732) - Conds:RS_84._col3=RS_345._col0(Inner),Output:["_col1","_col2","_col4","_col6","_col7","_col8","_col9","_col10"] - <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_345] - PartitionCols:_col0 - Group By Operator [GBY_344] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_75] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_74] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=386) - Conds:RS_70._col1=RS_312._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_312] - PartitionCols:_col0 - Select Operator [SEL_311] (rows=80000000 width=284) - Output:["_col0","_col1","_col2","_col3"] - TableScan [TS_65] (rows=80000000 width=284) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name"] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_70] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_279] (rows=525327388 width=110) - Conds:RS_343._col0=RS_290._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_290] - PartitionCols:_col0 - Select Operator [SEL_287] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_284] (rows=652 width=8) - predicate:((d_year = 2002) and (d_year) IN (2001, 2002)) - TableScan [TS_62] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_343] - PartitionCols:_col0 - Select Operator [SEL_342] (rows=525327388 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_341] (rows=525327388 width=114) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_68_date_dim_d_date_sk_min) AND DynamicValue(RS_68_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_68_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_59] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] - <-Reducer 22 [BROADCAST_EDGE] vectorized - BROADCAST [RS_340] - Group By Operator [GBY_339] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_302] - Group By Operator [GBY_298] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_291] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_287] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_84] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_282] (rows=31888273 width=440) - Conds:RS_81._col3=RS_338._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6"] - <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_338] - PartitionCols:_col0 - Select Operator [SEL_337] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_336] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_56] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_55] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=391) - Conds:RS_51._col1=RS_313._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_313] + Top N Key Operator [TNK_154] (rows=19066162 width=732) + keys:_col8, _col7, _col9,top n:100 + Filter Operator [FIL_87] (rows=19066162 width=732) + predicate:CASE WHEN (_col4 is not null) THEN (CASE WHEN (_col2) THEN (((_col6 / _col1) > (_col10 / _col4))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_284] (rows=38132324 width=732) + Conds:RS_84._col3=RS_346._col0(Inner),Output:["_col1","_col2","_col4","_col6","_col7","_col8","_col9","_col10"] + <-Reducer 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_346] + PartitionCols:_col0 + Group By Operator [GBY_345] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_75] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_74] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_281] (rows=525327388 width=386) + Conds:RS_70._col1=RS_313._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_313] + PartitionCols:_col0 + Select Operator [SEL_312] (rows=80000000 width=284) + Output:["_col0","_col1","_col2","_col3"] + TableScan [TS_65] (rows=80000000 width=284) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name"] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_70] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=110) + Conds:RS_344._col0=RS_291._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_291] + PartitionCols:_col0 + Select Operator [SEL_288] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_285] (rows=652 width=8) + predicate:((d_year = 2002) and (d_year) IN (2001, 2002)) + TableScan [TS_62] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_344] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_311] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_51] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_277] (rows=143930993 width=115) - Conds:RS_335._col0=RS_292._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_292] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_287] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_335] - PartitionCols:_col0 - Select Operator [SEL_334] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_333] (rows=143930993 width=119) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_49_date_dim_d_date_sk_min) AND DynamicValue(RS_49_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_49_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_40] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] - <-Reducer 23 [BROADCAST_EDGE] vectorized - BROADCAST [RS_332] - Group By Operator [GBY_331] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_303] - Group By Operator [GBY_299] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_293] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_287] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_81] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_281] (rows=26666666 width=328) - Conds:RS_320._col0=RS_330._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_330] - PartitionCols:_col0 - Select Operator [SEL_329] (rows=26666666 width=212) - Output:["_col0","_col1"] - Filter Operator [FIL_328] (rows=26666666 width=212) - predicate:(_col3 > 0) - Select Operator [SEL_327] (rows=80000000 width=212) - Output:["_col0","_col3"] - Group By Operator [GBY_326] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_36] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_35] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_276] (rows=525327388 width=386) - Conds:RS_31._col1=RS_315._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_315] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_311] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_275] (rows=525327388 width=110) - Conds:RS_325._col0=RS_296._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_296] - PartitionCols:_col0 - Select Operator [SEL_289] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_286] (rows=652 width=8) - predicate:((d_year = 2001) and (d_year) IN (2001, 2002)) - Please refer to the previous TableScan [TS_62] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_325] - PartitionCols:_col0 - Select Operator [SEL_324] (rows=525327388 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_323] (rows=525327388 width=114) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_date_dim_d_date_sk_min) AND DynamicValue(RS_29_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] - <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_322] - Group By Operator [GBY_321] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_305] - Group By Operator [GBY_301] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_297] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_289] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_320] - PartitionCols:_col0 - Select Operator [SEL_319] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_318] (rows=26666666 width=212) - predicate:(_col3 > 0) - Select Operator [SEL_317] (rows=80000000 width=212) - Output:["_col0","_col3"] - Group By Operator [GBY_316] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_16] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_15] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_274] (rows=143930993 width=391) - Conds:RS_11._col1=RS_314._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_314] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_311] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_273] (rows=143930993 width=115) - Conds:RS_310._col0=RS_294._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_294] - PartitionCols:_col0 - Select Operator [SEL_288] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_285] (rows=652 width=8) - predicate:((d_year = 2001) and (d_year) IN (2001, 2002)) - Please refer to the previous TableScan [TS_62] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_310] - PartitionCols:_col0 - Select Operator [SEL_309] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_308] (rows=143930993 width=119) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_date_dim_d_date_sk_min) AND DynamicValue(RS_9_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_307] - Group By Operator [GBY_306] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_304] - Group By Operator [GBY_300] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_295] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_288] + Select Operator [SEL_343] (rows=525327388 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_342] (rows=525327388 width=114) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_68_date_dim_d_date_sk_min) AND DynamicValue(RS_68_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_68_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_59] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] + <-Reducer 22 [BROADCAST_EDGE] vectorized + BROADCAST [RS_341] + Group By Operator [GBY_340] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_303] + Group By Operator [GBY_299] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_292] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_288] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_84] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_283] (rows=31888273 width=440) + Conds:RS_81._col3=RS_339._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col6"] + <-Reducer 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_339] + PartitionCols:_col0 + Select Operator [SEL_338] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_337] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_56] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_55] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_279] (rows=143930993 width=391) + Conds:RS_51._col1=RS_314._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_314] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_312] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_51] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=115) + Conds:RS_336._col0=RS_293._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_293] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_288] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_336] + PartitionCols:_col0 + Select Operator [SEL_335] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_334] (rows=143930993 width=119) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_49_date_dim_d_date_sk_min) AND DynamicValue(RS_49_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_49_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_40] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] + <-Reducer 23 [BROADCAST_EDGE] vectorized + BROADCAST [RS_333] + Group By Operator [GBY_332] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_304] + Group By Operator [GBY_300] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_294] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_288] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_81] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_282] (rows=26666666 width=328) + Conds:RS_321._col0=RS_331._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_331] + PartitionCols:_col0 + Select Operator [SEL_330] (rows=26666666 width=212) + Output:["_col0","_col1"] + Filter Operator [FIL_329] (rows=26666666 width=212) + predicate:(_col3 > 0) + Select Operator [SEL_328] (rows=80000000 width=212) + Output:["_col0","_col3"] + Group By Operator [GBY_327] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_36] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_35] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_277] (rows=525327388 width=386) + Conds:RS_31._col1=RS_316._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_316] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_312] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_276] (rows=525327388 width=110) + Conds:RS_326._col0=RS_297._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_297] + PartitionCols:_col0 + Select Operator [SEL_290] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_287] (rows=652 width=8) + predicate:((d_year = 2001) and (d_year) IN (2001, 2002)) + Please refer to the previous TableScan [TS_62] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_326] + PartitionCols:_col0 + Select Operator [SEL_325] (rows=525327388 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_324] (rows=525327388 width=114) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_date_dim_d_date_sk_min) AND DynamicValue(RS_29_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] + <-Reducer 25 [BROADCAST_EDGE] vectorized + BROADCAST [RS_323] + Group By Operator [GBY_322] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_306] + Group By Operator [GBY_302] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_298] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_290] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_321] + PartitionCols:_col0 + Select Operator [SEL_320] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_319] (rows=26666666 width=212) + predicate:(_col3 > 0) + Select Operator [SEL_318] (rows=80000000 width=212) + Output:["_col0","_col3"] + Group By Operator [GBY_317] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_16] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_15] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_275] (rows=143930993 width=391) + Conds:RS_11._col1=RS_315._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_315] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_312] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_274] (rows=143930993 width=115) + Conds:RS_311._col0=RS_295._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_295] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_286] (rows=652 width=8) + predicate:((d_year = 2001) and (d_year) IN (2001, 2002)) + Please refer to the previous TableScan [TS_62] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_311] + PartitionCols:_col0 + Select Operator [SEL_310] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_309] (rows=143930993 width=119) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_date_dim_d_date_sk_min) AND DynamicValue(RS_9_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_308] + Group By Operator [GBY_307] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_305] + Group By Operator [GBY_301] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_296] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_289] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query75.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query75.q.out index b1341a2fdb..63d2612327 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query75.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query75.q.out @@ -199,388 +199,390 @@ Stage-0 limit:-1 Stage-1 Reducer 10 vectorized - File Output Operator [FS_611] - Select Operator [SEL_610] (rows=100 width=160) + File Output Operator [FS_612] + Select Operator [SEL_611] (rows=100 width=160) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Limit [LIM_609] (rows=100 width=152) + Limit [LIM_610] (rows=100 width=152) Number of rows:100 - Select Operator [SEL_608] (rows=7853634 width=152) + Select Operator [SEL_609] (rows=7853634 width=152) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_169] Select Operator [SEL_168] (rows=7853634 width=152) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_167] (rows=7853634 width=256) - predicate:((CAST( _col10 AS decimal(17,2)) / CAST( _col4 AS decimal(17,2))) < 0.9) - Merge Join Operator [MERGEJOIN_512] (rows=23560904 width=256) - Conds:RS_604._col0, _col1, _col2, _col3=RS_607._col0, _col1, _col2, _col3(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col10","_col11"] - <-Reducer 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_607] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_606] (rows=40320 width=136) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 - Group By Operator [GBY_605] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 26 [SIMPLE_EDGE] - <-Reducer 25 [CONTAINS] vectorized - Reduce Output Operator [RS_635] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_634] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_633] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 24 [SIMPLE_EDGE] - <-Reducer 23 [CONTAINS] - Reduce Output Operator [RS_536] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_535] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_533] (rows=455263131 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_532] (rows=455263131 width=177) - Conds:RS_99._col1, _col2=RS_598._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_598] - PartitionCols:_col0, _col1 - Select Operator [SEL_596] (rows=28798881 width=121) - Output:["_col0","_col1","_col2","_col3"] - TableScan [TS_9] (rows=28798881 width=121) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_quantity","cr_return_amount"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_99] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_504] (rows=273092954 width=139) - Conds:RS_96._col1=RS_593._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_593] - PartitionCols:_col0 - Select Operator [SEL_589] (rows=45745 width=19) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_588] (rows=45745 width=109) - predicate:((i_category = 'Sports') and i_manufact_id is not null and i_category_id is not null and i_brand_id is not null and i_class_id is not null) - TableScan [TS_6] (rows=462000 width=109) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id","i_category","i_manufact_id"] - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_96] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_503] (rows=286549727 width=123) - Conds:RS_632._col0=RS_565._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_565] - PartitionCols:_col0 - Select Operator [SEL_556] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_552] (rows=652 width=8) - predicate:(d_year = 2002) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 43 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_632] - PartitionCols:_col0 - Select Operator [SEL_631] (rows=286549727 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_630] (rows=286549727 width=127) - predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_94_date_dim_d_date_sk_min) AND DynamicValue(RS_94_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_94_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_82] (rows=287989836 width=127) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] - <-Reducer 28 [BROADCAST_EDGE] vectorized - BROADCAST [RS_629] - Group By Operator [GBY_628] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_580] - Group By Operator [GBY_574] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_566] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_556] - <-Reducer 31 [CONTAINS] - Reduce Output Operator [RS_545] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_544] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_542] (rows=843378354 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_541] (rows=843378354 width=205) - Conds:RS_120._col1, _col2=RS_619._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 40 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_619] - PartitionCols:_col0, _col1 - Select Operator [SEL_617] (rows=57591150 width=119) - Output:["_col0","_col1","_col2","_col3"] - TableScan [TS_30] (rows=57591150 width=119) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_quantity","sr_return_amt"] - <-Reducer 30 [SIMPLE_EDGE] - SHUFFLE [RS_120] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_507] (rows=524244194 width=134) - Conds:RS_117._col1=RS_594._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_594] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_589] - <-Reducer 29 [SIMPLE_EDGE] - SHUFFLE [RS_117] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_506] (rows=550076554 width=118) - Conds:RS_640._col0=RS_567._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_567] - PartitionCols:_col0 - Select Operator [SEL_557] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_553] (rows=652 width=8) - predicate:(d_year = 2002) - Please refer to the previous TableScan [TS_3] - <-Map 44 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_640] - PartitionCols:_col0 - Select Operator [SEL_639] (rows=550076554 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_638] (rows=550076554 width=122) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_115_date_dim_d_date_sk_min) AND DynamicValue(RS_115_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_115_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_103] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] - <-Reducer 32 [BROADCAST_EDGE] vectorized - BROADCAST [RS_637] - Group By Operator [GBY_636] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_581] - Group By Operator [GBY_575] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_568] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_557] - <-Reducer 35 [CONTAINS] - Reduce Output Operator [RS_550] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_549] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_547] (rows=242954637 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_546] (rows=242954637 width=199) - Conds:RS_148._col1, _col2=RS_627._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 42 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_627] - PartitionCols:_col0, _col1 - Select Operator [SEL_625] (rows=14398467 width=118) - Output:["_col0","_col1","_col2","_col3"] - TableScan [TS_58] (rows=14398467 width=118) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_quantity","wr_return_amt"] - <-Reducer 34 [SIMPLE_EDGE] - SHUFFLE [RS_148] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_510] (rows=137205980 width=139) - Conds:RS_145._col1=RS_595._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_595] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_589] - <-Reducer 33 [SIMPLE_EDGE] - SHUFFLE [RS_145] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_509] (rows=143966864 width=123) - Conds:RS_645._col0=RS_569._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_569] - PartitionCols:_col0 - Select Operator [SEL_558] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_554] (rows=652 width=8) - predicate:(d_year = 2002) - Please refer to the previous TableScan [TS_3] - <-Map 45 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_645] - PartitionCols:_col0 - Select Operator [SEL_644] (rows=143966864 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_643] (rows=143966864 width=127) - predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_143_date_dim_d_date_sk_min) AND DynamicValue(RS_143_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_143_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_131] (rows=144002668 width=127) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] - <-Reducer 36 [BROADCAST_EDGE] vectorized - BROADCAST [RS_642] - Group By Operator [GBY_641] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_582] - Group By Operator [GBY_576] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_570] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_558] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_604] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_603] (rows=40320 width=136) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 - Group By Operator [GBY_602] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 7 [SIMPLE_EDGE] - <-Reducer 19 [CONTAINS] - Reduce Output Operator [RS_531] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_530] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_528] (rows=242954637 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_527] (rows=242954637 width=199) - Conds:RS_66._col1, _col2=RS_626._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 42 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_626] - PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_625] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_501] (rows=137205980 width=139) - Conds:RS_63._col1=RS_592._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_592] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_589] - <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_500] (rows=143966864 width=123) - Conds:RS_624._col0=RS_563._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_563] - PartitionCols:_col0 - Select Operator [SEL_555] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_551] (rows=652 width=8) - predicate:(d_year = 2001) - Please refer to the previous TableScan [TS_3] - <-Map 41 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_624] - PartitionCols:_col0 - Select Operator [SEL_623] (rows=143966864 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_622] (rows=143966864 width=127) - predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_61_date_dim_d_date_sk_min) AND DynamicValue(RS_61_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_61_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_49] (rows=144002668 width=127) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] - <-Reducer 20 [BROADCAST_EDGE] vectorized - BROADCAST [RS_621] - Group By Operator [GBY_620] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_579] - Group By Operator [GBY_573] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_564] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_555] - <-Reducer 6 [CONTAINS] vectorized - Reduce Output Operator [RS_601] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_600] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_599] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 15 [CONTAINS] - Reduce Output Operator [RS_526] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_525] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_523] (rows=843378354 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_522] (rows=843378354 width=205) - Conds:RS_38._col1, _col2=RS_618._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 40 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_618] - PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_617] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_38] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_498] (rows=524244194 width=134) - Conds:RS_35._col1=RS_591._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_591] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_589] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_497] (rows=550076554 width=118) - Conds:RS_616._col0=RS_561._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_561] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_555] - <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_616] - PartitionCols:_col0 - Select Operator [SEL_615] (rows=550076554 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_614] (rows=550076554 width=122) - predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_33_date_dim_d_date_sk_min) AND DynamicValue(RS_33_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_33_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_21] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] - <-Reducer 16 [BROADCAST_EDGE] vectorized - BROADCAST [RS_613] - Group By Operator [GBY_612] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_578] - Group By Operator [GBY_572] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_562] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_555] - <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_517] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_516] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_514] (rows=455263131 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_513] (rows=455263131 width=177) - Conds:RS_17._col1, _col2=RS_597._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_597] - PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_596] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_495] (rows=273092954 width=139) - Conds:RS_14._col1=RS_590._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_590] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_589] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_14] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_494] (rows=286549727 width=123) - Conds:RS_587._col0=RS_559._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_559] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_555] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_587] - PartitionCols:_col0 - Select Operator [SEL_586] (rows=286549727 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_585] (rows=286549727 width=127) - predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_12_date_dim_d_date_sk_min) AND DynamicValue(RS_12_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_12_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=287989836 width=127) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] - <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_584] - Group By Operator [GBY_583] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_577] - Group By Operator [GBY_571] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_560] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_555] + Top N Key Operator [TNK_258] (rows=7853634 width=256) + keys:(_col10 - _col4),top n:100 + Filter Operator [FIL_167] (rows=7853634 width=256) + predicate:((CAST( _col10 AS decimal(17,2)) / CAST( _col4 AS decimal(17,2))) < 0.9) + Merge Join Operator [MERGEJOIN_513] (rows=23560904 width=256) + Conds:RS_605._col0, _col1, _col2, _col3=RS_608._col0, _col1, _col2, _col3(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col10","_col11"] + <-Reducer 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_608] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_607] (rows=40320 width=136) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 + Group By Operator [GBY_606] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 26 [SIMPLE_EDGE] + <-Reducer 25 [CONTAINS] vectorized + Reduce Output Operator [RS_636] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_635] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_634] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 24 [SIMPLE_EDGE] + <-Reducer 23 [CONTAINS] + Reduce Output Operator [RS_537] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_536] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_534] (rows=455263131 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_533] (rows=455263131 width=177) + Conds:RS_99._col1, _col2=RS_599._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_599] + PartitionCols:_col0, _col1 + Select Operator [SEL_597] (rows=28798881 width=121) + Output:["_col0","_col1","_col2","_col3"] + TableScan [TS_9] (rows=28798881 width=121) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_quantity","cr_return_amount"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_99] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_505] (rows=273092954 width=139) + Conds:RS_96._col1=RS_594._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_594] + PartitionCols:_col0 + Select Operator [SEL_590] (rows=45745 width=19) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_589] (rows=45745 width=109) + predicate:((i_category = 'Sports') and i_manufact_id is not null and i_category_id is not null and i_brand_id is not null and i_class_id is not null) + TableScan [TS_6] (rows=462000 width=109) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id","i_category","i_manufact_id"] + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_96] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_504] (rows=286549727 width=123) + Conds:RS_633._col0=RS_566._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_566] + PartitionCols:_col0 + Select Operator [SEL_557] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_553] (rows=652 width=8) + predicate:(d_year = 2002) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 43 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_633] + PartitionCols:_col0 + Select Operator [SEL_632] (rows=286549727 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_631] (rows=286549727 width=127) + predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_94_date_dim_d_date_sk_min) AND DynamicValue(RS_94_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_94_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_82] (rows=287989836 width=127) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] + <-Reducer 28 [BROADCAST_EDGE] vectorized + BROADCAST [RS_630] + Group By Operator [GBY_629] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_581] + Group By Operator [GBY_575] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_567] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_557] + <-Reducer 31 [CONTAINS] + Reduce Output Operator [RS_546] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_545] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_543] (rows=843378354 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_542] (rows=843378354 width=205) + Conds:RS_120._col1, _col2=RS_620._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 40 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_620] + PartitionCols:_col0, _col1 + Select Operator [SEL_618] (rows=57591150 width=119) + Output:["_col0","_col1","_col2","_col3"] + TableScan [TS_30] (rows=57591150 width=119) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_quantity","sr_return_amt"] + <-Reducer 30 [SIMPLE_EDGE] + SHUFFLE [RS_120] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_508] (rows=524244194 width=134) + Conds:RS_117._col1=RS_595._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_595] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_590] + <-Reducer 29 [SIMPLE_EDGE] + SHUFFLE [RS_117] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_507] (rows=550076554 width=118) + Conds:RS_641._col0=RS_568._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_568] + PartitionCols:_col0 + Select Operator [SEL_558] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_554] (rows=652 width=8) + predicate:(d_year = 2002) + Please refer to the previous TableScan [TS_3] + <-Map 44 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_641] + PartitionCols:_col0 + Select Operator [SEL_640] (rows=550076554 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_639] (rows=550076554 width=122) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_115_date_dim_d_date_sk_min) AND DynamicValue(RS_115_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_115_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_103] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] + <-Reducer 32 [BROADCAST_EDGE] vectorized + BROADCAST [RS_638] + Group By Operator [GBY_637] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_582] + Group By Operator [GBY_576] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_569] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_558] + <-Reducer 35 [CONTAINS] + Reduce Output Operator [RS_551] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_550] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_548] (rows=242954637 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_547] (rows=242954637 width=199) + Conds:RS_148._col1, _col2=RS_628._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 42 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_628] + PartitionCols:_col0, _col1 + Select Operator [SEL_626] (rows=14398467 width=118) + Output:["_col0","_col1","_col2","_col3"] + TableScan [TS_58] (rows=14398467 width=118) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_quantity","wr_return_amt"] + <-Reducer 34 [SIMPLE_EDGE] + SHUFFLE [RS_148] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_511] (rows=137205980 width=139) + Conds:RS_145._col1=RS_596._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_596] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_590] + <-Reducer 33 [SIMPLE_EDGE] + SHUFFLE [RS_145] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_510] (rows=143966864 width=123) + Conds:RS_646._col0=RS_570._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_570] + PartitionCols:_col0 + Select Operator [SEL_559] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_555] (rows=652 width=8) + predicate:(d_year = 2002) + Please refer to the previous TableScan [TS_3] + <-Map 45 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_646] + PartitionCols:_col0 + Select Operator [SEL_645] (rows=143966864 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_644] (rows=143966864 width=127) + predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_143_date_dim_d_date_sk_min) AND DynamicValue(RS_143_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_143_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_131] (rows=144002668 width=127) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] + <-Reducer 36 [BROADCAST_EDGE] vectorized + BROADCAST [RS_643] + Group By Operator [GBY_642] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_583] + Group By Operator [GBY_577] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_571] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_559] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_605] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_604] (rows=40320 width=136) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 + Group By Operator [GBY_603] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 7 [SIMPLE_EDGE] + <-Reducer 19 [CONTAINS] + Reduce Output Operator [RS_532] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_531] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_529] (rows=242954637 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_528] (rows=242954637 width=199) + Conds:RS_66._col1, _col2=RS_627._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 42 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_627] + PartitionCols:_col0, _col1 + Please refer to the previous Select Operator [SEL_626] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_502] (rows=137205980 width=139) + Conds:RS_63._col1=RS_593._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_593] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_590] + <-Reducer 17 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_501] (rows=143966864 width=123) + Conds:RS_625._col0=RS_564._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_564] + PartitionCols:_col0 + Select Operator [SEL_556] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_552] (rows=652 width=8) + predicate:(d_year = 2001) + Please refer to the previous TableScan [TS_3] + <-Map 41 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_625] + PartitionCols:_col0 + Select Operator [SEL_624] (rows=143966864 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_623] (rows=143966864 width=127) + predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_61_date_dim_d_date_sk_min) AND DynamicValue(RS_61_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_61_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_49] (rows=144002668 width=127) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] + <-Reducer 20 [BROADCAST_EDGE] vectorized + BROADCAST [RS_622] + Group By Operator [GBY_621] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_580] + Group By Operator [GBY_574] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_565] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_556] + <-Reducer 6 [CONTAINS] vectorized + Reduce Output Operator [RS_602] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_601] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_600] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 15 [CONTAINS] + Reduce Output Operator [RS_527] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_526] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_524] (rows=843378354 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_523] (rows=843378354 width=205) + Conds:RS_38._col1, _col2=RS_619._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 40 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_619] + PartitionCols:_col0, _col1 + Please refer to the previous Select Operator [SEL_618] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_38] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_499] (rows=524244194 width=134) + Conds:RS_35._col1=RS_592._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_592] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_590] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_498] (rows=550076554 width=118) + Conds:RS_617._col0=RS_562._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_562] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_556] + <-Map 39 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_617] + PartitionCols:_col0 + Select Operator [SEL_616] (rows=550076554 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_615] (rows=550076554 width=122) + predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_33_date_dim_d_date_sk_min) AND DynamicValue(RS_33_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_33_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_21] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] + <-Reducer 16 [BROADCAST_EDGE] vectorized + BROADCAST [RS_614] + Group By Operator [GBY_613] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_579] + Group By Operator [GBY_573] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_563] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_556] + <-Reducer 4 [CONTAINS] + Reduce Output Operator [RS_518] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_517] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_515] (rows=455263131 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_514] (rows=455263131 width=177) + Conds:RS_17._col1, _col2=RS_598._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_598] + PartitionCols:_col0, _col1 + Please refer to the previous Select Operator [SEL_597] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_496] (rows=273092954 width=139) + Conds:RS_14._col1=RS_591._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_591] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_590] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_14] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_495] (rows=286549727 width=123) + Conds:RS_588._col0=RS_560._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_560] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_556] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_588] + PartitionCols:_col0 + Select Operator [SEL_587] (rows=286549727 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_586] (rows=286549727 width=127) + predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_12_date_dim_d_date_sk_min) AND DynamicValue(RS_12_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_12_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=287989836 width=127) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] + <-Reducer 12 [BROADCAST_EDGE] vectorized + BROADCAST [RS_585] + Group By Operator [GBY_584] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_578] + Group By Operator [GBY_572] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_561] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_556] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query76.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query76.q.out index ce4f7cb061..24c268f4ab 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query76.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query76.q.out @@ -73,124 +73,124 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_175] - Limit [LIM_174] (rows=100 width=408) + File Output Operator [FS_180] + Limit [LIM_179] (rows=100 width=408) Number of rows:100 - Select Operator [SEL_173] (rows=5600 width=408) + Select Operator [SEL_178] (rows=5600 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_172] - Group By Operator [GBY_171] (rows=5600 width=408) + SHUFFLE [RS_177] + Group By Operator [GBY_176] (rows=5600 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 4 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_161] + Reduce Output Operator [RS_166] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_160] (rows=224000 width=408) + Group By Operator [GBY_165] (rows=224000 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Top N Key Operator [TNK_159] (rows=26219002 width=388) + Top N Key Operator [TNK_164] (rows=26219002 width=388) keys:_col0, _col1, _col2, _col3, _col4,top n:100 - Select Operator [SEL_157] (rows=1433911 width=399) + Select Operator [SEL_162] (rows=1433911 width=399) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_156] (rows=1433911 width=209) - Conds:RS_39._col1=RS_185._col0(Inner),Output:["_col2","_col4","_col5","_col7"] + Merge Join Operator [MERGEJOIN_161] (rows=1433911 width=209) + Conds:RS_39._col1=RS_190._col0(Inner),Output:["_col2","_col4","_col5","_col7"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_185] + SHUFFLE [RS_190] PartitionCols:_col0 - Select Operator [SEL_184] (rows=462000 width=94) + Select Operator [SEL_189] (rows=462000 width=94) Output:["_col0","_col1"] TableScan [TS_34] (rows=462000 width=94) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_39] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_142] (rows=1433911 width=123) - Conds:RS_183._col0=RS_165._col0(Inner),Output:["_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_147] (rows=1433911 width=123) + Conds:RS_188._col0=RS_170._col0(Inner),Output:["_col1","_col2","_col4","_col5"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_165] + SHUFFLE [RS_170] PartitionCols:_col0 - Select Operator [SEL_162] (rows=73049 width=12) + Select Operator [SEL_167] (rows=73049 width=12) Output:["_col0","_col1","_col2"] TableScan [TS_0] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_183] + SHUFFLE [RS_188] PartitionCols:_col0 - Select Operator [SEL_182] (rows=1433911 width=119) + Select Operator [SEL_187] (rows=1433911 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_181] (rows=1433911 width=123) + Filter Operator [FIL_186] (rows=1433911 width=123) predicate:(cs_warehouse_sk is null and cs_sold_date_sk is not null) TableScan [TS_29] (rows=287989836 width=123) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_warehouse_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 3 [CONTAINS] - Reduce Output Operator [RS_149] + Reduce Output Operator [RS_154] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_148] (rows=224000 width=408) + Group By Operator [GBY_153] (rows=224000 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Top N Key Operator [TNK_147] (rows=26219002 width=388) + Top N Key Operator [TNK_152] (rows=26219002 width=388) keys:_col0, _col1, _col2, _col3, _col4,top n:100 - Select Operator [SEL_145] (rows=24749363 width=387) + Select Operator [SEL_150] (rows=24749363 width=387) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_144] (rows=24749363 width=204) - Conds:RS_10._col4=RS_170._col0(Inner),Output:["_col1","_col2","_col5","_col7"] + Merge Join Operator [MERGEJOIN_149] (rows=24749363 width=204) + Conds:RS_10._col4=RS_175._col0(Inner),Output:["_col1","_col2","_col5","_col7"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_170] + SHUFFLE [RS_175] PartitionCols:_col0 - Select Operator [SEL_169] (rows=462000 width=94) + Select Operator [SEL_174] (rows=462000 width=94) Output:["_col0","_col1"] TableScan [TS_5] (rows=462000 width=94) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_10] PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_138] (rows=24749363 width=118) - Conds:RS_163._col0=RS_168._col0(Inner),Output:["_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_143] (rows=24749363 width=118) + Conds:RS_168._col0=RS_173._col0(Inner),Output:["_col1","_col2","_col4","_col5"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] + SHUFFLE [RS_168] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_162] + Please refer to the previous Select Operator [SEL_167] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_168] + SHUFFLE [RS_173] PartitionCols:_col0 - Select Operator [SEL_167] (rows=24749363 width=114) + Select Operator [SEL_172] (rows=24749363 width=114) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_166] (rows=24749363 width=118) + Filter Operator [FIL_171] (rows=24749363 width=118) predicate:(ss_addr_sk is null and ss_sold_date_sk is not null) TableScan [TS_2] (rows=575995635 width=118) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] <-Reducer 8 [CONTAINS] - Reduce Output Operator [RS_155] + Reduce Output Operator [RS_160] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_154] (rows=224000 width=408) + Group By Operator [GBY_159] (rows=224000 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Top N Key Operator [TNK_153] (rows=26219002 width=388) + Top N Key Operator [TNK_158] (rows=26219002 width=388) keys:_col0, _col1, _col2, _col3, _col4,top n:100 - Select Operator [SEL_151] (rows=35728 width=394) + Select Operator [SEL_156] (rows=35728 width=394) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_150] (rows=35728 width=209) - Conds:RS_24._col1=RS_180._col0(Inner),Output:["_col2","_col4","_col5","_col7"] + Merge Join Operator [MERGEJOIN_155] (rows=35728 width=209) + Conds:RS_24._col1=RS_185._col0(Inner),Output:["_col2","_col4","_col5","_col7"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_180] + SHUFFLE [RS_185] PartitionCols:_col0 - Select Operator [SEL_179] (rows=462000 width=94) + Select Operator [SEL_184] (rows=462000 width=94) Output:["_col0","_col1"] TableScan [TS_19] (rows=462000 width=94) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_140] (rows=35728 width=123) - Conds:RS_178._col0=RS_164._col0(Inner),Output:["_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_145] (rows=35728 width=123) + Conds:RS_183._col0=RS_169._col0(Inner),Output:["_col1","_col2","_col4","_col5"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_164] + SHUFFLE [RS_169] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_162] + Please refer to the previous Select Operator [SEL_167] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_178] + SHUFFLE [RS_183] PartitionCols:_col0 - Select Operator [SEL_177] (rows=35728 width=119) + Select Operator [SEL_182] (rows=35728 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_176] (rows=35728 width=123) + Filter Operator [FIL_181] (rows=35728 width=123) predicate:(ws_web_page_sk is null and ws_sold_date_sk is not null) TableScan [TS_14] (rows=144002668 width=123) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_ext_sales_price"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query77.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query77.q.out index 95ab61bed2..c2758b7033 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query77.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query77.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[225][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 14' is a cross product +Warning: Shuffle Join MERGEJOIN[227][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 14' is a cross product PREHOOK: query: explain with ss as (select s_store_sk, @@ -263,107 +263,107 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_271] - Limit [LIM_270] (rows=100 width=438) + File Output Operator [FS_273] + Limit [LIM_272] (rows=100 width=438) Number of rows:100 - Select Operator [SEL_269] (rows=564 width=438) + Select Operator [SEL_271] (rows=564 width=438) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_268] - Select Operator [SEL_267] (rows=564 width=438) + SHUFFLE [RS_270] + Select Operator [SEL_269] (rows=564 width=438) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_266] (rows=564 width=446) + Group By Operator [GBY_268] (rows=564 width=446) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 5 [SIMPLE_EDGE] <-Reducer 14 [CONTAINS] - Reduce Output Operator [RS_230] + Reduce Output Operator [RS_232] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_229] (rows=564 width=446) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_228] (rows=531 width=435) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_226] (rows=10 width=439) + Top N Key Operator [TNK_231] (rows=564 width=446) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_230] (rows=564 width=446) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_228] (rows=10 width=439) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_225] (rows=10 width=452) + Merge Join Operator [MERGEJOIN_227] (rows=10 width=452) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_278] - Group By Operator [GBY_277] (rows=10 width=228) + PARTITION_ONLY_SHUFFLE [RS_280] + Group By Operator [GBY_279] (rows=10 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_45] PartitionCols:_col0 Group By Operator [GBY_44] (rows=2550 width=227) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col1 - Merge Join Operator [MERGEJOIN_212] (rows=286549727 width=227) - Conds:RS_276._col0=RS_242._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_214] (rows=286549727 width=227) + Conds:RS_278._col0=RS_244._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_242] + PARTITION_ONLY_SHUFFLE [RS_244] PartitionCols:_col0 - Select Operator [SEL_238] (rows=8116 width=4) + Select Operator [SEL_240] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_237] (rows=8116 width=98) + Filter Operator [FIL_239] (rows=8116 width=98) predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-08-04 00:00:00' AND TIMESTAMP'1998-09-03 00:00:00' TableScan [TS_3] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_276] + SHUFFLE [RS_278] PartitionCols:_col0 - Select Operator [SEL_275] (rows=286549727 width=231) + Select Operator [SEL_277] (rows=286549727 width=231) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_274] (rows=286549727 width=231) + Filter Operator [FIL_276] (rows=286549727 width=231) predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_41_date_dim_d_date_sk_min) AND DynamicValue(RS_41_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_41_date_dim_d_date_sk_bloom_filter))) TableScan [TS_34] (rows=287989836 width=231) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_ext_sales_price","cs_net_profit"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_273] - Group By Operator [GBY_272] (rows=1 width=12) + BROADCAST [RS_275] + Group By Operator [GBY_274] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_252] - Group By Operator [GBY_249] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_254] + Group By Operator [GBY_251] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_243] (rows=8116 width=4) + Select Operator [SEL_245] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Reducer 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_283] - Group By Operator [GBY_282] (rows=1 width=224) + PARTITION_ONLY_SHUFFLE [RS_285] + Group By Operator [GBY_284] (rows=1 width=224) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"] <-Reducer 16 [CUSTOM_SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_59] Group By Operator [GBY_58] (rows=1 width=224) Output:["_col0","_col1"],aggregations:["sum(_col1)","sum(_col2)"] - Merge Join Operator [MERGEJOIN_213] (rows=3199657 width=183) - Conds:RS_281._col0=RS_244._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_215] (rows=3199657 width=183) + Conds:RS_283._col0=RS_246._col0(Inner),Output:["_col1","_col2"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_244] + PARTITION_ONLY_SHUFFLE [RS_246] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] + SHUFFLE [RS_283] PartitionCols:_col0 - Select Operator [SEL_280] (rows=28798881 width=223) + Select Operator [SEL_282] (rows=28798881 width=223) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_279] (rows=28798881 width=223) + Filter Operator [FIL_281] (rows=28798881 width=223) predicate:cr_returned_date_sk is not null TableScan [TS_48] (rows=28798881 width=223) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_return_amount","cr_net_loss"] <-Reducer 20 [CONTAINS] - Reduce Output Operator [RS_236] + Reduce Output Operator [RS_238] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_235] (rows=564 width=446) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_234] (rows=531 width=435) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_232] (rows=394 width=435) + Top N Key Operator [TNK_237] (rows=564 width=446) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_236] (rows=564 width=446) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_234] (rows=394 width=435) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_231] (rows=394 width=335) - Conds:RS_290._col0=RS_295._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_233] (rows=394 width=335) + Conds:RS_292._col0=RS_297._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] <-Reducer 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_290] + SHUFFLE [RS_292] PartitionCols:_col0 - Group By Operator [GBY_289] (rows=206 width=228) + Group By Operator [GBY_291] (rows=206 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 18 [SIMPLE_EDGE] SHUFFLE [RS_79] @@ -372,36 +372,36 @@ Stage-0 Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","sum(_col2)"],keys:_col0 Select Operator [SEL_76] (rows=143931136 width=227) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_214] (rows=143931136 width=227) - Conds:RS_288._col0=RS_245._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_216] (rows=143931136 width=227) + Conds:RS_290._col0=RS_247._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_245] + PARTITION_ONLY_SHUFFLE [RS_247] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_288] + SHUFFLE [RS_290] PartitionCols:_col0 - Select Operator [SEL_287] (rows=143931136 width=231) + Select Operator [SEL_289] (rows=143931136 width=231) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_286] (rows=143931136 width=231) + Filter Operator [FIL_288] (rows=143931136 width=231) predicate:(ws_sold_date_sk is not null and ws_web_page_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_74_date_dim_d_date_sk_min) AND DynamicValue(RS_74_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_74_date_dim_d_date_sk_bloom_filter))) TableScan [TS_67] (rows=144002668 width=231) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_web_page_sk","ws_ext_sales_price","ws_net_profit"] <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_285] - Group By Operator [GBY_284] (rows=1 width=12) + BROADCAST [RS_287] + Group By Operator [GBY_286] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_253] - Group By Operator [GBY_250] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_255] + Group By Operator [GBY_252] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_246] (rows=8116 width=4) + Select Operator [SEL_248] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Reducer 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_295] + SHUFFLE [RS_297] PartitionCols:_col0 - Group By Operator [GBY_294] (rows=188 width=227) + Group By Operator [GBY_296] (rows=188 width=227) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 22 [SIMPLE_EDGE] SHUFFLE [RS_94] @@ -410,36 +410,36 @@ Stage-0 Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","sum(_col2)"],keys:_col0 Select Operator [SEL_91] (rows=13129719 width=217) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_215] (rows=13129719 width=217) - Conds:RS_293._col0=RS_247._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_217] (rows=13129719 width=217) + Conds:RS_295._col0=RS_249._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_247] + PARTITION_ONLY_SHUFFLE [RS_249] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_293] + SHUFFLE [RS_295] PartitionCols:_col0 - Select Operator [SEL_292] (rows=13129719 width=221) + Select Operator [SEL_294] (rows=13129719 width=221) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_291] (rows=13129719 width=221) + Filter Operator [FIL_293] (rows=13129719 width=221) predicate:(wr_web_page_sk is not null and wr_returned_date_sk is not null) TableScan [TS_82] (rows=14398467 width=221) default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_web_page_sk","wr_return_amt","wr_net_loss"] <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_224] + Reduce Output Operator [RS_226] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_223] (rows=564 width=446) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_222] (rows=531 width=435) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_220] (rows=127 width=436) + Top N Key Operator [TNK_225] (rows=564 width=446) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_224] (rows=564 width=446) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_222] (rows=127 width=436) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_219] (rows=127 width=379) - Conds:RS_260._col0=RS_265._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_221] (rows=127 width=379) + Conds:RS_262._col0=RS_267._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_265] + SHUFFLE [RS_267] PartitionCols:_col0 - Group By Operator [GBY_264] (rows=85 width=227) + Group By Operator [GBY_266] (rows=85 width=227) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_27] @@ -448,25 +448,25 @@ Stage-0 Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","sum(_col2)"],keys:_col0 Select Operator [SEL_24] (rows=53634860 width=220) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_211] (rows=53634860 width=220) - Conds:RS_263._col0=RS_241._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_213] (rows=53634860 width=220) + Conds:RS_265._col0=RS_243._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_241] + PARTITION_ONLY_SHUFFLE [RS_243] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_263] + SHUFFLE [RS_265] PartitionCols:_col0 - Select Operator [SEL_262] (rows=53634860 width=223) + Select Operator [SEL_264] (rows=53634860 width=223) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_261] (rows=53634860 width=223) + Filter Operator [FIL_263] (rows=53634860 width=223) predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) TableScan [TS_15] (rows=57591150 width=223) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_store_sk","sr_return_amt","sr_net_loss"] <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_260] + SHUFFLE [RS_262] PartitionCols:_col0 - Group By Operator [GBY_259] (rows=84 width=227) + Group By Operator [GBY_261] (rows=84 width=227) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] @@ -475,30 +475,30 @@ Stage-0 Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","sum(_col2)"],keys:_col0 Select Operator [SEL_9] (rows=525329897 width=217) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_210] (rows=525329897 width=217) - Conds:RS_258._col0=RS_239._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_212] (rows=525329897 width=217) + Conds:RS_260._col0=RS_241._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_239] + PARTITION_ONLY_SHUFFLE [RS_241] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_258] + SHUFFLE [RS_260] PartitionCols:_col0 - Select Operator [SEL_257] (rows=525329897 width=221) + Select Operator [SEL_259] (rows=525329897 width=221) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_256] (rows=525329897 width=221) + Filter Operator [FIL_258] (rows=525329897 width=221) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=221) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_255] - Group By Operator [GBY_254] (rows=1 width=12) + BROADCAST [RS_257] + Group By Operator [GBY_256] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_251] - Group By Operator [GBY_248] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_253] + Group By Operator [GBY_250] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_240] (rows=8116 width=4) + Select Operator [SEL_242] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_238] + Please refer to the previous Select Operator [SEL_240] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query78.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query78.q.out index ecb434d3cd..dd4aaedfe3 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query78.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query78.q.out @@ -155,191 +155,193 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_269] - Limit [LIM_268] (rows=100 width=484) + File Output Operator [FS_270] + Limit [LIM_269] (rows=100 width=484) Number of rows:100 - Select Operator [SEL_267] (rows=5221812635288 width=483) + Select Operator [SEL_268] (rows=5221812635288 width=483) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_73] Select Operator [SEL_72] (rows=5221812635288 width=719) Output:["_col0","_col1","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - Merge Join Operator [MERGEJOIN_220] (rows=5221812635288 width=703) - Conds:RS_69._col0, _col1=RS_266._col0, _col1(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col11","_col12","_col13"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_266] - PartitionCols:_col0, _col1 - Filter Operator [FIL_265] (rows=113538342 width=239) - predicate:(_col2 > 0L) - Group By Operator [GBY_264] (rows=113538342 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_62] - PartitionCols:_col0, _col1 - Group By Operator [GBY_61] (rows=113538342 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col2, _col3 - Merge Join Operator [MERGEJOIN_218] (rows=113538342 width=235) - Conds:RS_227._col0=RS_58._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_227] - PartitionCols:_col0 - Select Operator [SEL_222] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_221] (rows=652 width=8) - predicate:(d_year = 2000) - TableScan [TS_0] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_58] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=113538342 width=239) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_55] (rows=113538342 width=242) - predicate:_col8 is null - Merge Join Operator [MERGEJOIN_217] (rows=254644510 width=242) - Conds:RS_261._col1, _col3=RS_263._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_261] - PartitionCols:_col1, _col3 - Select Operator [SEL_260] (rows=143930993 width=243) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_259] (rows=143930993 width=243) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_47] (rows=144002668 width=243) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_order_number","ws_quantity","ws_wholesale_cost","ws_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_258] - Group By Operator [GBY_257] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_234] - Group By Operator [GBY_231] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_228] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_222] - <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_263] - PartitionCols:_col0, _col1 - Select Operator [SEL_262] (rows=14398467 width=8) - Output:["_col0","_col1"] - TableScan [TS_50] (rows=14398467 width=8) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_69] - PartitionCols:_col0, _col1 - Merge Join Operator [MERGEJOIN_219] (rows=65074513381 width=471) - Conds:RS_244._col1=RS_256._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8"] - <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_244] - PartitionCols:_col1 - Select Operator [SEL_243] (rows=319876350 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_242] (rows=319876350 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col0, _col1 - Group By Operator [GBY_17] (rows=319876350 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col3, _col2 - Merge Join Operator [MERGEJOIN_214] (rows=319876350 width=229) - Conds:RS_223._col0=RS_14._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_222] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_14] - PartitionCols:_col0 - Select Operator [SEL_12] (rows=319876350 width=233) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_11] (rows=319876350 width=236) - predicate:_col8 is null - Merge Join Operator [MERGEJOIN_213] (rows=857669906 width=236) - Conds:RS_239._col1, _col3=RS_241._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] - PartitionCols:_col1, _col3 - Select Operator [SEL_238] (rows=525327388 width=233) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_237] (rows=525327388 width=233) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_3] (rows=575995635 width=233) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_wholesale_cost","ss_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_236] - Group By Operator [GBY_235] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_232] - Group By Operator [GBY_229] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_224] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_222] - <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_241] - PartitionCols:_col0, _col1 - Select Operator [SEL_240] (rows=57591150 width=8) - Output:["_col0","_col1"] - TableScan [TS_6] (rows=57591150 width=8) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_256] - PartitionCols:_col0 - Select Operator [SEL_255] (rows=285117831 width=235) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_254] (rows=285117831 width=239) - predicate:(_col2 > 0L) - Select Operator [SEL_253] (rows=285117831 width=239) - Output:["_col1","_col2","_col3","_col4"] - Group By Operator [GBY_252] (rows=285117831 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_39] - PartitionCols:_col0, _col1 - Group By Operator [GBY_38] (rows=285117831 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col2, _col3 - Merge Join Operator [MERGEJOIN_216] (rows=285117831 width=235) - Conds:RS_225._col0=RS_35._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_222] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col0 - Select Operator [SEL_33] (rows=285117831 width=239) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_32] (rows=285117831 width=240) - predicate:_col8 is null - Merge Join Operator [MERGEJOIN_215] (rows=466377701 width=240) - Conds:RS_249._col2, _col3=RS_251._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_249] - PartitionCols:_col2, _col3 - Select Operator [SEL_248] (rows=285117831 width=242) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_247] (rows=285117831 width=242) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_34_date_dim_d_date_sk_min) AND DynamicValue(RS_34_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_34_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_24] (rows=287989836 width=242) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_order_number","cs_quantity","cs_wholesale_cost","cs_sales_price"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_246] - Group By Operator [GBY_245] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_233] - Group By Operator [GBY_230] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_226] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_222] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_251] - PartitionCols:_col0, _col1 - Select Operator [SEL_250] (rows=28798881 width=8) - Output:["_col0","_col1"] - TableScan [TS_27] (rows=28798881 width=8) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] + Top N Key Operator [TNK_114] (rows=5221812635288 width=703) + keys:_col0, _col1, _col2, _col3, _col4, (CASE WHEN (_col11 is not null) THEN (_col11) ELSE (0L) END + CASE WHEN (_col6 is not null) THEN (_col6) ELSE (0L) END), (CASE WHEN (_col12 is not null) THEN (_col12) ELSE (0) END + CASE WHEN (_col7 is not null) THEN (_col7) ELSE (0) END), (CASE WHEN (_col13 is not null) THEN (_col13) ELSE (0) END + CASE WHEN (_col8 is not null) THEN (_col8) ELSE (0) END), round((UDFToDouble(_col2) / UDFToDouble(CASE WHEN ((_col11 is not null and _col6 is not null)) THEN ((_col11 + _col6)) ELSE (1L) END)), 2),top n:100 + Merge Join Operator [MERGEJOIN_221] (rows=5221812635288 width=703) + Conds:RS_69._col0, _col1=RS_267._col0, _col1(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8","_col11","_col12","_col13"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_267] + PartitionCols:_col0, _col1 + Filter Operator [FIL_266] (rows=113538342 width=239) + predicate:(_col2 > 0L) + Group By Operator [GBY_265] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_62] + PartitionCols:_col0, _col1 + Group By Operator [GBY_61] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col2, _col3 + Merge Join Operator [MERGEJOIN_219] (rows=113538342 width=235) + Conds:RS_228._col0=RS_58._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_228] + PartitionCols:_col0 + Select Operator [SEL_223] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_222] (rows=652 width=8) + predicate:(d_year = 2000) + TableScan [TS_0] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_56] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_55] (rows=113538342 width=242) + predicate:_col8 is null + Merge Join Operator [MERGEJOIN_218] (rows=254644510 width=242) + Conds:RS_262._col1, _col3=RS_264._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_262] + PartitionCols:_col1, _col3 + Select Operator [SEL_261] (rows=143930993 width=243) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_260] (rows=143930993 width=243) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_47] (rows=144002668 width=243) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_order_number","ws_quantity","ws_wholesale_cost","ws_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_259] + Group By Operator [GBY_258] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_235] + Group By Operator [GBY_232] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_229] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_223] + <-Map 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_264] + PartitionCols:_col0, _col1 + Select Operator [SEL_263] (rows=14398467 width=8) + Output:["_col0","_col1"] + TableScan [TS_50] (rows=14398467 width=8) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_69] + PartitionCols:_col0, _col1 + Merge Join Operator [MERGEJOIN_220] (rows=65074513381 width=471) + Conds:RS_245._col1=RS_257._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col7","_col8"] + <-Reducer 3 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_245] + PartitionCols:_col1 + Select Operator [SEL_244] (rows=319876350 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"] + Group By Operator [GBY_243] (rows=319876350 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0, _col1 + Group By Operator [GBY_17] (rows=319876350 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col3, _col2 + Merge Join Operator [MERGEJOIN_215] (rows=319876350 width=229) + Conds:RS_224._col0=RS_14._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_224] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_223] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_14] + PartitionCols:_col0 + Select Operator [SEL_12] (rows=319876350 width=233) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_11] (rows=319876350 width=236) + predicate:_col8 is null + Merge Join Operator [MERGEJOIN_214] (rows=857669906 width=236) + Conds:RS_240._col1, _col3=RS_242._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_240] + PartitionCols:_col1, _col3 + Select Operator [SEL_239] (rows=525327388 width=233) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_238] (rows=525327388 width=233) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_3] (rows=575995635 width=233) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_wholesale_cost","ss_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_237] + Group By Operator [GBY_236] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_233] + Group By Operator [GBY_230] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_225] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_223] + <-Map 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_242] + PartitionCols:_col0, _col1 + Select Operator [SEL_241] (rows=57591150 width=8) + Output:["_col0","_col1"] + TableScan [TS_6] (rows=57591150 width=8) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_257] + PartitionCols:_col0 + Select Operator [SEL_256] (rows=285117831 width=235) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_255] (rows=285117831 width=239) + predicate:(_col2 > 0L) + Select Operator [SEL_254] (rows=285117831 width=239) + Output:["_col1","_col2","_col3","_col4"] + Group By Operator [GBY_253] (rows=285117831 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_39] + PartitionCols:_col0, _col1 + Group By Operator [GBY_38] (rows=285117831 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col2, _col3 + Merge Join Operator [MERGEJOIN_217] (rows=285117831 width=235) + Conds:RS_226._col0=RS_35._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_226] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_223] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col0 + Select Operator [SEL_33] (rows=285117831 width=239) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_32] (rows=285117831 width=240) + predicate:_col8 is null + Merge Join Operator [MERGEJOIN_216] (rows=466377701 width=240) + Conds:RS_250._col2, _col3=RS_252._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_250] + PartitionCols:_col2, _col3 + Select Operator [SEL_249] (rows=285117831 width=242) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_248] (rows=285117831 width=242) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_34_date_dim_d_date_sk_min) AND DynamicValue(RS_34_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_34_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_24] (rows=287989836 width=242) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_order_number","cs_quantity","cs_wholesale_cost","cs_sales_price"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_247] + Group By Operator [GBY_246] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_234] + Group By Operator [GBY_231] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_227] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_223] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_252] + PartitionCols:_col0, _col1 + Select Operator [SEL_251] (rows=28798881 width=8) + Output:["_col0","_col1"] + TableScan [TS_27] (rows=28798881 width=8) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query79.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query79.q.out index 9e9bbec9e2..2828fb007f 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query79.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query79.q.out @@ -71,93 +71,95 @@ Stage-0 limit:-1 Stage-1 Reducer 3 vectorized - File Output Operator [FS_124] - Limit [LIM_123] (rows=100 width=776) + File Output Operator [FS_125] + Limit [LIM_124] (rows=100 width=776) Number of rows:100 - Select Operator [SEL_122] (rows=479121995 width=776) + Select Operator [SEL_123] (rows=479121995 width=776) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_32] Select Operator [SEL_31] (rows=479121995 width=776) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Merge Join Operator [MERGEJOIN_99] (rows=479121995 width=685) - Conds:RS_101._col0=RS_121._col1(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_101] - PartitionCols:_col0 - Select Operator [SEL_100] (rows=80000000 width=184) - Output:["_col0","_col1","_col2"] - TableScan [TS_0] (rows=80000000 width=184) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_first_name","c_last_name"] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_121] - PartitionCols:_col1 - Select Operator [SEL_120] (rows=479121995 width=508) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_119] (rows=479121995 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_25] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_24] (rows=479121995 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col3, _col5, _col10 - Merge Join Operator [MERGEJOIN_98] (rows=479121995 width=318) - Conds:RS_20._col2=RS_118._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col10"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_118] - PartitionCols:_col0 - Select Operator [SEL_117] (rows=6415 width=4) - Output:["_col0"] - Filter Operator [FIL_116] (rows=6415 width=12) - predicate:((hd_vehicle_count > 0) or (hd_dep_count = 8)) - TableScan [TS_11] (rows=7200 width=12) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_20] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_97] (rows=479121995 width=322) - Conds:RS_17._col4=RS_115._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col10"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_115] - PartitionCols:_col0 - Select Operator [SEL_114] (rows=1704 width=97) - Output:["_col0","_col1"] - Filter Operator [FIL_113] (rows=1704 width=100) - predicate:s_number_employees BETWEEN 200 AND 295 - TableScan [TS_8] (rows=1704 width=100) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_number_employees","s_city"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_96] (rows=479121995 width=233) - Conds:RS_112._col0=RS_104._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_104] - PartitionCols:_col0 - Select Operator [SEL_103] (rows=391 width=4) - Output:["_col0"] - Filter Operator [FIL_102] (rows=391 width=12) - predicate:((d_dow = 1) and (d_year) IN (1998, 1999, 2000)) - TableScan [TS_5] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] - <-Map 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_112] - PartitionCols:_col0 - Select Operator [SEL_111] (rows=479121995 width=237) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_110] (rows=479121995 width=237) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_2] (rows=575995635 width=237) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_109] - Group By Operator [GBY_108] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_107] - Group By Operator [GBY_106] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_105] (rows=391 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_103] + Top N Key Operator [TNK_56] (rows=479121995 width=685) + keys:_col2, _col1, substr(_col5, 1, 30), _col7,top n:100 + Merge Join Operator [MERGEJOIN_100] (rows=479121995 width=685) + Conds:RS_102._col0=RS_122._col1(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_102] + PartitionCols:_col0 + Select Operator [SEL_101] (rows=80000000 width=184) + Output:["_col0","_col1","_col2"] + TableScan [TS_0] (rows=80000000 width=184) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_first_name","c_last_name"] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_122] + PartitionCols:_col1 + Select Operator [SEL_121] (rows=479121995 width=508) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Group By Operator [GBY_120] (rows=479121995 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_25] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_24] (rows=479121995 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col3, _col5, _col10 + Merge Join Operator [MERGEJOIN_99] (rows=479121995 width=318) + Conds:RS_20._col2=RS_119._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col10"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_119] + PartitionCols:_col0 + Select Operator [SEL_118] (rows=6415 width=4) + Output:["_col0"] + Filter Operator [FIL_117] (rows=6415 width=12) + predicate:((hd_vehicle_count > 0) or (hd_dep_count = 8)) + TableScan [TS_11] (rows=7200 width=12) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_20] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_98] (rows=479121995 width=322) + Conds:RS_17._col4=RS_116._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col10"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_116] + PartitionCols:_col0 + Select Operator [SEL_115] (rows=1704 width=97) + Output:["_col0","_col1"] + Filter Operator [FIL_114] (rows=1704 width=100) + predicate:s_number_employees BETWEEN 200 AND 295 + TableScan [TS_8] (rows=1704 width=100) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_number_employees","s_city"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_97] (rows=479121995 width=233) + Conds:RS_113._col0=RS_105._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_105] + PartitionCols:_col0 + Select Operator [SEL_104] (rows=391 width=4) + Output:["_col0"] + Filter Operator [FIL_103] (rows=391 width=12) + predicate:((d_dow = 1) and (d_year) IN (1998, 1999, 2000)) + TableScan [TS_5] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] + <-Map 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_113] + PartitionCols:_col0 + Select Operator [SEL_112] (rows=479121995 width=237) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_111] (rows=479121995 width=237) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_2] (rows=575995635 width=237) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_110] + Group By Operator [GBY_109] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_108] + Group By Operator [GBY_107] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_106] (rows=391 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_104] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query8.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query8.q.out index 170bccf406..ed1501bf59 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query8.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query8.q.out @@ -245,141 +245,141 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_149] - Limit [LIM_148] (rows=1 width=200) + File Output Operator [FS_154] + Limit [LIM_153] (rows=1 width=200) Number of rows:100 - Select Operator [SEL_147] (rows=1 width=200) + Select Operator [SEL_152] (rows=1 width=200) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - Group By Operator [GBY_145] (rows=1 width=200) + SHUFFLE [RS_151] + Group By Operator [GBY_150] (rows=1 width=200) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 Group By Operator [GBY_56] (rows=401 width=200) Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col6 - Top N Key Operator [TNK_84] (rows=525329897 width=194) + Top N Key Operator [TNK_87] (rows=525329897 width=194) keys:_col6,top n:100 - Merge Join Operator [MERGEJOIN_118] (rows=525329897 width=194) + Merge Join Operator [MERGEJOIN_123] (rows=525329897 width=194) Conds:RS_52._col1=RS_53._col1(Inner),Output:["_col2","_col6"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_53] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_117] (rows=1 width=92) - Conds:RS_141._col0=RS_144._col2(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_122] (rows=1 width=92) + Conds:RS_146._col0=RS_149._col2(Inner),Output:["_col1","_col2"] <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] + SHUFFLE [RS_149] PartitionCols:_col2 - Select Operator [SEL_143] (rows=1704 width=276) + Select Operator [SEL_148] (rows=1704 width=276) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_142] (rows=1704 width=181) + Filter Operator [FIL_147] (rows=1704 width=181) predicate:substr(s_zip, 1, 2) is not null TableScan [TS_42] (rows=1704 width=181) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_zip"] <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_141] + SHUFFLE [RS_146] PartitionCols:_col0 - Select Operator [SEL_140] (rows=1 width=184) + Select Operator [SEL_145] (rows=1 width=184) Output:["_col0"] - Filter Operator [FIL_139] (rows=1 width=192) + Filter Operator [FIL_144] (rows=1 width=192) predicate:(_col1 = 2L) - Group By Operator [GBY_138] (rows=5633 width=192) + Group By Operator [GBY_143] (rows=5633 width=192) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Union 10 [SIMPLE_EDGE] <-Reducer 16 [CONTAINS] vectorized - Reduce Output Operator [RS_170] + Reduce Output Operator [RS_175] PartitionCols:_col0 - Group By Operator [GBY_169] (rows=5633 width=192) + Group By Operator [GBY_174] (rows=5633 width=192) Output:["_col0","_col1"],aggregations:["count(_col1)"],keys:_col0 - Group By Operator [GBY_168] (rows=1126 width=192) + Group By Operator [GBY_173] (rows=1126 width=192) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_167] + SHUFFLE [RS_172] PartitionCols:_col0 - Group By Operator [GBY_166] (rows=1126 width=192) + Group By Operator [GBY_171] (rows=1126 width=192) Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 - Select Operator [SEL_165] (rows=2253 width=97) + Select Operator [SEL_170] (rows=2253 width=97) Output:["_col0"] - Filter Operator [FIL_164] (rows=2253 width=97) + Filter Operator [FIL_169] (rows=2253 width=97) predicate:(_col1 > 10L) - Group By Operator [GBY_163] (rows=6761 width=97) + Group By Operator [GBY_168] (rows=6761 width=97) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col0 Group By Operator [GBY_24] (rows=67610 width=97) Output:["_col0","_col1"],aggregations:["count()"],keys:_col1 - Merge Join Operator [MERGEJOIN_116] (rows=26666667 width=89) - Conds:RS_159._col0=RS_162._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_121] (rows=26666667 width=89) + Conds:RS_164._col0=RS_167._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_159] + SHUFFLE [RS_164] PartitionCols:_col0 - Select Operator [SEL_158] (rows=40000000 width=93) + Select Operator [SEL_163] (rows=40000000 width=93) Output:["_col0","_col1"] - Filter Operator [FIL_157] (rows=40000000 width=93) + Filter Operator [FIL_162] (rows=40000000 width=93) predicate:substr(substr(ca_zip, 1, 5), 1, 2) is not null TableScan [TS_14] (rows=40000000 width=93) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_zip"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_162] + SHUFFLE [RS_167] PartitionCols:_col0 - Select Operator [SEL_161] (rows=26666667 width=4) + Select Operator [SEL_166] (rows=26666667 width=4) Output:["_col0"] - Filter Operator [FIL_160] (rows=26666667 width=89) + Filter Operator [FIL_165] (rows=26666667 width=89) predicate:((c_preferred_cust_flag = 'Y') and c_current_addr_sk is not null) TableScan [TS_17] (rows=80000000 width=89) default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_current_addr_sk","c_preferred_cust_flag"] <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_156] + Reduce Output Operator [RS_161] PartitionCols:_col0 - Group By Operator [GBY_155] (rows=5633 width=192) + Group By Operator [GBY_160] (rows=5633 width=192) Output:["_col0","_col1"],aggregations:["count(_col1)"],keys:_col0 - Group By Operator [GBY_154] (rows=10141 width=192) + Group By Operator [GBY_159] (rows=10141 width=192) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_153] + SHUFFLE [RS_158] PartitionCols:_col0 - Group By Operator [GBY_152] (rows=141974 width=192) + Group By Operator [GBY_157] (rows=141974 width=192) Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 - Select Operator [SEL_151] (rows=20000000 width=89) + Select Operator [SEL_156] (rows=20000000 width=89) Output:["_col0"] - Filter Operator [FIL_150] (rows=20000000 width=89) + Filter Operator [FIL_155] (rows=20000000 width=89) predicate:((substr(ca_zip, 1, 5)) IN ('89436', '30868', '65085', '22977', '83927', '77557', '58429', '40697', '80614', '10502', '32779', '91137', '61265', '98294', '17921', '18427', '21203', '59362', '87291', '84093', '21505', '17184', '10866', '67898', '25797', '28055', '18377', '80332', '74535', '21757', '29742', '90885', '29898', '17819', '40811', '25990', '47513', '89531', '91068', '10391', '18846', '99223', '82637', '41368', '83658', '86199', '81625', '26696', '89338', '88425', '32200', '81427', '19053', '77471', '36610', '99823', '43276', '41249', '48584', '83550', '82276', '18842', '78890', '14090', '38123', '40936', '34425', '19850', '43286', '80072', '79188', '54191', '11395', '50497', '84861', '90733', '21068', '57666', '37119', '25004', '57835', '70067', '62878', '95806', '19303', '18840', '19124', '29785', '16737', '16022', '49613', '89977', '68310', '60069', '98360', '48649', '39050', '41793', '25002', '27413', '39736', '47208', '16515', '94808', '57648', '15009', '80015', '42961', '63982', '21744', '71853', '81087', '67468', '34175', '64008', '20261', '11201', '51799', '48043', '45645', '61163', '48375', '36447', '57042', '21218', '41100', '89951', '22745', '35851', '83326', '61125', '78298', '80752', '49858', '52940', '96976', '63792', '11376', '53582', '18717', '90226', '50530', '94203', '99447', '27670', '96577', '57856', '56372', '16165', '23427', '54561', '28806', '44439', '22926', '30123', '61451', '92397', '56979', '92309', '70873', '13355', '21801', '46346', '37562', '56458', '28286', '47306', '99555', '69399', '26234', '47546', '49661', '88601', '35943', '39936', '25632', '24611', '44166', '56648', '30379', '59785', '11110', '14329', '93815', '52226', '71381', '13842', '25612', '63294', '14664', '21077', '82626', '18799', '60915', '81020', '56447', '76619', '11433', '13414', '42548', '92713', '70467', '30884', '47484', '16072', '38936', '13036', '88376', '45539', '35901', '19506', '65690', '73957', '71850', '49231', '14276', '20005', '18384', '76615', '11635', '38177', '55607', '41369', '95447', '58581', '58149', '91946', '33790', '76232', '75692', '95464', '22246', '51061', '56692', '53121', '77209', '15482', '10688', '14868', '45907', '73520', '72666', '25734', '17959', '24677', '66446', '94627', '53535', '15560', '41967', '69297', '11929', '59403', '33283', '52232', '57350', '43933', '40921', '36635', '10827', '71286', '19736', '80619', '25251', '95042', '15526', '36496', '55854', '49124', '81980', '35375', '49157', '63512', '28944', '14946', '36503', '54010', '18767', '23969', '43905', '66979', '33113', '21286', '58471', '59080', '13395', '79144', '70373', '67031', '38360', '26705', '50906', '52406', '26066', '73146', '15884', '31897', '30045', '61068', '45550', '92454', '13376', '14354', '19770', '22928', '97790', '50723', '46081', '30202', '14410', '20223', '88500', '67298', '13261', '14172', '81410', '93578', '83583', '46047', '94167', '82564', '21156', '15799', '86709', '37931', '74703', '83103', '23054', '70470', '72008', '49247', '91911', '69998', '20961', '70070', '63197', '54853', '88191', '91830', '49521', '19454', '81450', '89091', '62378', '25683', '61869', '51744', '36580', '85778', '36871', '48121', '28810', '83712', '45486', '67393', '26935', '42393', '20132', '55349', '86057', '21309', '80218', '10094', '11357', '48819', '39734', '40758', '30432', '21204', '29467', '30214', '61024', '55307', '74621', '11622', '68908', '33032', '52868', '99194', '99900', '84936', '69036', '99149', '45013', '32895', '59004', '32322', '14933', '32936', '33562', '72550', '27385', '58049', '58200', '16808', '21360', '32961', '18586', '79307', '15492') and substr(substr(ca_zip, 1, 5), 1, 2) is not null) TableScan [TS_6] (rows=40000000 width=89) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_zip"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_52] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_115] (rows=525329897 width=110) - Conds:RS_137._col0=RS_129._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_120] (rows=525329897 width=110) + Conds:RS_142._col0=RS_134._col0(Inner),Output:["_col1","_col2"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_129] + PARTITION_ONLY_SHUFFLE [RS_134] PartitionCols:_col0 - Select Operator [SEL_128] (rows=130 width=4) + Select Operator [SEL_133] (rows=130 width=4) Output:["_col0"] - Filter Operator [FIL_127] (rows=130 width=12) + Filter Operator [FIL_132] (rows=130 width=12) predicate:((d_year = 2002) and (d_qoy = 1)) TableScan [TS_3] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_137] + SHUFFLE [RS_142] PartitionCols:_col0 - Select Operator [SEL_136] (rows=525329897 width=114) + Select Operator [SEL_141] (rows=525329897 width=114) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_135] (rows=525329897 width=114) + Filter Operator [FIL_140] (rows=525329897 width=114) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_50_date_dim_d_date_sk_min) AND DynamicValue(RS_50_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_50_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=114) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_net_profit"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_134] - Group By Operator [GBY_133] (rows=1 width=12) + BROADCAST [RS_139] + Group By Operator [GBY_138] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_132] - Group By Operator [GBY_131] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_137] + Group By Operator [GBY_136] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_130] (rows=130 width=4) + Select Operator [SEL_135] (rows=130 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_128] + Please refer to the previous Select Operator [SEL_133] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query80.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query80.q.out index b18f89373c..72a54928c2 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query80.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query80.q.out @@ -249,28 +249,28 @@ Stage-0 limit:100 Stage-1 Reducer 10 vectorized - File Output Operator [FS_430] - Limit [LIM_429] (rows=100 width=619) + File Output Operator [FS_432] + Limit [LIM_431] (rows=100 width=619) Number of rows:100 - Select Operator [SEL_428] (rows=59581 width=619) + Select Operator [SEL_430] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_427] - Select Operator [SEL_426] (rows=59581 width=619) + SHUFFLE [RS_429] + Select Operator [SEL_428] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_425] (rows=59581 width=627) + Group By Operator [GBY_427] (rows=59581 width=627) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 8 [SIMPLE_EDGE] <-Reducer 18 [CONTAINS] vectorized - Reduce Output Operator [RS_444] + Reduce Output Operator [RS_446] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_443] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_442] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_441] (rows=38846 width=619) + Top N Key Operator [TNK_445] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_444] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_443] (rows=38846 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_440] (rows=38846 width=436) + Group By Operator [GBY_442] (rows=38846 width=436) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 17 [SIMPLE_EDGE] SHUFFLE [RS_71] @@ -279,99 +279,99 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_68] (rows=154681759 width=322) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_363] (rows=154681759 width=322) - Conds:RS_65._col1=RS_439._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] + Merge Join Operator [MERGEJOIN_365] (rows=154681759 width=322) + Conds:RS_65._col1=RS_441._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] <-Map 32 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_439] + SHUFFLE [RS_441] PartitionCols:_col0 - Select Operator [SEL_438] (rows=46000 width=104) + Select Operator [SEL_440] (rows=46000 width=104) Output:["_col0","_col1"] TableScan [TS_51] (rows=46000 width=104) default@catalog_page,catalog_page,Tbl:COMPLETE,Col:COMPLETE,Output:["cp_catalog_page_sk","cp_catalog_page_id"] <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_65] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_362] (rows=154681759 width=226) - Conds:RS_62._col3=RS_416._col0(Inner),Output:["_col1","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_364] (rows=154681759 width=226) + Conds:RS_62._col3=RS_418._col0(Inner),Output:["_col1","_col5","_col6","_col9","_col10"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_416] + SHUFFLE [RS_418] PartitionCols:_col0 - Select Operator [SEL_414] (rows=1150 width=4) + Select Operator [SEL_416] (rows=1150 width=4) Output:["_col0"] - Filter Operator [FIL_413] (rows=1150 width=89) + Filter Operator [FIL_415] (rows=1150 width=89) predicate:(p_channel_tv = 'N') TableScan [TS_11] (rows=2300 width=89) default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_tv"] <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_62] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_361] (rows=154681759 width=230) - Conds:RS_59._col2=RS_411._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_363] (rows=154681759 width=230) + Conds:RS_59._col2=RS_413._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_411] + SHUFFLE [RS_413] PartitionCols:_col0 - Select Operator [SEL_409] (rows=154000 width=4) + Select Operator [SEL_411] (rows=154000 width=4) Output:["_col0"] - Filter Operator [FIL_408] (rows=154000 width=115) + Filter Operator [FIL_410] (rows=154000 width=115) predicate:(i_current_price > 50) TableScan [TS_8] (rows=462000 width=115) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price"] <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_59] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_360] (rows=464045263 width=322) - Conds:RS_56._col0=RS_391._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_362] (rows=464045263 width=322) + Conds:RS_56._col0=RS_393._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_391] + SHUFFLE [RS_393] PartitionCols:_col0 - Select Operator [SEL_388] (rows=8116 width=4) + Select Operator [SEL_390] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_387] (rows=8116 width=98) + Filter Operator [FIL_389] (rows=8116 width=98) predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-08-04 00:00:00' AND TIMESTAMP'1998-09-03 00:00:00' TableScan [TS_5] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Reducer 30 [SIMPLE_EDGE] SHUFFLE [RS_56] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_359] (rows=464045263 width=326) - Conds:RS_435._col2, _col4=RS_437._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_361] (rows=464045263 width=326) + Conds:RS_437._col2, _col4=RS_439._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_435] + SHUFFLE [RS_437] PartitionCols:_col2, _col4 - Select Operator [SEL_434] (rows=283691906 width=243) + Select Operator [SEL_436] (rows=283691906 width=243) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_433] (rows=283691906 width=243) + Filter Operator [FIL_435] (rows=283691906 width=243) predicate:(cs_promo_sk is not null and cs_sold_date_sk is not null and cs_catalog_page_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) TableScan [TS_37] (rows=287989836 width=243) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_catalog_page_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_ext_sales_price","cs_net_profit"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_432] - Group By Operator [GBY_431] (rows=1 width=12) + BROADCAST [RS_434] + Group By Operator [GBY_433] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_399] - Group By Operator [GBY_396] (rows=1 width=12) + SHUFFLE [RS_401] + Group By Operator [GBY_398] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_392] (rows=8116 width=4) + Select Operator [SEL_394] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_388] + Please refer to the previous Select Operator [SEL_390] <-Map 31 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_437] + SHUFFLE [RS_439] PartitionCols:_col0, _col1 - Select Operator [SEL_436] (rows=28798881 width=227) + Select Operator [SEL_438] (rows=28798881 width=227) Output:["_col0","_col1","_col2","_col3"] TableScan [TS_40] (rows=28798881 width=227) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_amount","cr_net_loss"] <-Reducer 24 [CONTAINS] vectorized - Reduce Output Operator [RS_458] + Reduce Output Operator [RS_460] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_457] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_456] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_455] (rows=53 width=615) + Top N Key Operator [TNK_459] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_458] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_457] (rows=53 width=615) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_454] (rows=53 width=436) + Group By Operator [GBY_456] (rows=53 width=436) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 23 [SIMPLE_EDGE] SHUFFLE [RS_109] @@ -380,84 +380,84 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_106] (rows=84869669 width=323) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_368] (rows=84869669 width=323) - Conds:RS_103._col2=RS_453._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] + Merge Join Operator [MERGEJOIN_370] (rows=84869669 width=323) + Conds:RS_103._col2=RS_455._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] <-Map 36 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_453] + SHUFFLE [RS_455] PartitionCols:_col0 - Select Operator [SEL_452] (rows=84 width=104) + Select Operator [SEL_454] (rows=84 width=104) Output:["_col0","_col1"] TableScan [TS_89] (rows=84 width=104) default@web_site,web_site,Tbl:COMPLETE,Col:COMPLETE,Output:["web_site_sk","web_site_id"] <-Reducer 22 [SIMPLE_EDGE] SHUFFLE [RS_103] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_367] (rows=84869669 width=227) - Conds:RS_100._col3=RS_417._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_369] (rows=84869669 width=227) + Conds:RS_100._col3=RS_419._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_417] + SHUFFLE [RS_419] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_414] + Please refer to the previous Select Operator [SEL_416] <-Reducer 21 [SIMPLE_EDGE] SHUFFLE [RS_100] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_366] (rows=84869669 width=231) - Conds:RS_97._col1=RS_412._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_368] (rows=84869669 width=231) + Conds:RS_97._col1=RS_414._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_412] + SHUFFLE [RS_414] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_409] + Please refer to the previous Select Operator [SEL_411] <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_97] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_365] (rows=254608997 width=359) - Conds:RS_94._col0=RS_393._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_367] (rows=254608997 width=359) + Conds:RS_94._col0=RS_395._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_393] + SHUFFLE [RS_395] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_388] + Please refer to the previous Select Operator [SEL_390] <-Reducer 34 [SIMPLE_EDGE] SHUFFLE [RS_94] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_364] (rows=254608997 width=363) - Conds:RS_449._col1, _col4=RS_451._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_366] (rows=254608997 width=363) + Conds:RS_451._col1, _col4=RS_453._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 33 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_449] + SHUFFLE [RS_451] PartitionCols:_col1, _col4 - Select Operator [SEL_448] (rows=143894769 width=243) + Select Operator [SEL_450] (rows=143894769 width=243) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_447] (rows=143894769 width=243) + Filter Operator [FIL_449] (rows=143894769 width=243) predicate:(ws_promo_sk is not null and ws_web_site_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) TableScan [TS_75] (rows=144002668 width=243) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_site_sk","ws_promo_sk","ws_order_number","ws_ext_sales_price","ws_net_profit"] <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_446] - Group By Operator [GBY_445] (rows=1 width=12) + BROADCAST [RS_448] + Group By Operator [GBY_447] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_400] - Group By Operator [GBY_397] (rows=1 width=12) + SHUFFLE [RS_402] + Group By Operator [GBY_399] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_394] (rows=8116 width=4) + Select Operator [SEL_396] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_388] + Please refer to the previous Select Operator [SEL_390] <-Map 35 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_451] + SHUFFLE [RS_453] PartitionCols:_col0, _col1 - Select Operator [SEL_450] (rows=14398467 width=221) + Select Operator [SEL_452] (rows=14398467 width=221) Output:["_col0","_col1","_col2","_col3"] TableScan [TS_78] (rows=14398467 width=221) default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_amt","wr_net_loss"] <-Reducer 7 [CONTAINS] vectorized - Reduce Output Operator [RS_424] + Reduce Output Operator [RS_426] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_423] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_422] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_421] (rows=822 width=617) + Top N Key Operator [TNK_425] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_424] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_423] (rows=822 width=617) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_420] (rows=822 width=436) + Group By Operator [GBY_422] (rows=822 width=436) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_34] @@ -466,71 +466,71 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_31] (rows=270716624 width=305) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_358] (rows=270716624 width=305) - Conds:RS_28._col2=RS_419._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] + Merge Join Operator [MERGEJOIN_360] (rows=270716624 width=305) + Conds:RS_28._col2=RS_421._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_419] + SHUFFLE [RS_421] PartitionCols:_col0 - Select Operator [SEL_418] (rows=1704 width=104) + Select Operator [SEL_420] (rows=1704 width=104) Output:["_col0","_col1"] TableScan [TS_14] (rows=1704 width=104) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_357] (rows=270716624 width=208) - Conds:RS_25._col3=RS_415._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_359] (rows=270716624 width=208) + Conds:RS_25._col3=RS_417._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_415] + SHUFFLE [RS_417] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_414] + Please refer to the previous Select Operator [SEL_416] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_356] (rows=270716624 width=212) - Conds:RS_22._col1=RS_410._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_358] (rows=270716624 width=212) + Conds:RS_22._col1=RS_412._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_410] + SHUFFLE [RS_412] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_409] + Please refer to the previous Select Operator [SEL_411] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_355] (rows=812149846 width=370) - Conds:RS_19._col0=RS_389._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_357] (rows=812149846 width=370) + Conds:RS_19._col0=RS_391._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_389] + SHUFFLE [RS_391] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_388] + Please refer to the previous Select Operator [SEL_390] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_354] (rows=812149846 width=374) - Conds:RS_405._col1, _col4=RS_407._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_356] (rows=812149846 width=374) + Conds:RS_407._col1, _col4=RS_409._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_405] + SHUFFLE [RS_407] PartitionCols:_col1, _col4 - Select Operator [SEL_404] (rows=501693263 width=233) + Select Operator [SEL_406] (rows=501693263 width=233) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_403] (rows=501693263 width=233) + Filter Operator [FIL_405] (rows=501693263 width=233) predicate:(ss_sold_date_sk is not null and ss_promo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=233) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_promo_sk","ss_ticket_number","ss_ext_sales_price","ss_net_profit"] <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_402] - Group By Operator [GBY_401] (rows=1 width=12) + BROADCAST [RS_404] + Group By Operator [GBY_403] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_398] - Group By Operator [GBY_395] (rows=1 width=12) + SHUFFLE [RS_400] + Group By Operator [GBY_397] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_390] (rows=8116 width=4) + Select Operator [SEL_392] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_388] + Please refer to the previous Select Operator [SEL_390] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_407] + SHUFFLE [RS_409] PartitionCols:_col0, _col1 - Select Operator [SEL_406] (rows=57591150 width=224) + Select Operator [SEL_408] (rows=57591150 width=224) Output:["_col0","_col1","_col2","_col3"] TableScan [TS_3] (rows=57591150 width=224) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_amt","sr_net_loss"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query81.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query81.q.out index 2b859c230c..b18dc7748b 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query81.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query81.q.out @@ -87,138 +87,140 @@ Stage-0 limit:-1 Stage-1 Reducer 4 vectorized - File Output Operator [FS_215] - Select Operator [SEL_214] (rows=100 width=1504) + File Output Operator [FS_216] + Select Operator [SEL_215] (rows=100 width=1503) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - Limit [LIM_213] (rows=100 width=1418) + Limit [LIM_214] (rows=100 width=1417) Number of rows:100 - Select Operator [SEL_212] (rows=1545467 width=1418) + Select Operator [SEL_213] (rows=1545467 width=1416) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_66] - Select Operator [SEL_65] (rows=1545467 width=1418) + Select Operator [SEL_65] (rows=1545467 width=1416) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] - Merge Join Operator [MERGEJOIN_181] (rows=1545467 width=1418) - Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col19"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Select Operator [SEL_58] (rows=1545467 width=227) - Output:["_col0","_col2"] - Filter Operator [FIL_57] (rows=1545467 width=227) - predicate:(_col2 > _col3) - Merge Join Operator [MERGEJOIN_180] (rows=4636401 width=227) - Conds:RS_205._col1=RS_211._col1(Inner),Output:["_col0","_col2","_col3"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_211] - PartitionCols:_col1 - Select Operator [SEL_210] (rows=12 width=198) - Output:["_col0","_col1"] - Filter Operator [FIL_209] (rows=12 width=206) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_208] (rows=12 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 - Select Operator [SEL_207] (rows=5266632 width=201) - Output:["_col0","_col2"] - Group By Operator [GBY_206] (rows=5266632 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col0 - Group By Operator [GBY_44] (rows=8749496 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_179] (rows=8749496 width=194) - Conds:RS_40._col2=RS_201._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - PartitionCols:_col0 - Select Operator [SEL_199] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_198] (rows=40000000 width=90) - predicate:ca_state is not null - TableScan [TS_12] (rows=40000000 width=90) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_178] (rows=8749496 width=112) - Conds:RS_193._col0=RS_197._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_197] - PartitionCols:_col0 - Select Operator [SEL_195] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_194] (rows=652 width=8) - predicate:(d_year = 1998) - TableScan [TS_9] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_193] - PartitionCols:_col0 - Select Operator [SEL_191] (rows=28221532 width=121) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_189] (rows=28221532 width=121) - predicate:(cr_returning_addr_sk is not null and cr_returned_date_sk is not null) - TableScan [TS_6] (rows=28798881 width=121) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_returning_customer_sk","cr_returning_addr_sk","cr_return_amt_inc_tax"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_205] - PartitionCols:_col1 - Filter Operator [FIL_204] (rows=4636401 width=201) - predicate:_col2 is not null - Select Operator [SEL_203] (rows=4636401 width=201) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_202] (rows=4636401 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=8574602 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_177] (rows=8574602 width=194) - Conds:RS_18._col2=RS_200._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_200] + Top N Key Operator [TNK_105] (rows=1545467 width=1418) + keys:_col1, _col3, _col4, _col5, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col19,top n:100 + Merge Join Operator [MERGEJOIN_182] (rows=1545467 width=1418) + Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col19"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_58] (rows=1545467 width=227) + Output:["_col0","_col2"] + Filter Operator [FIL_57] (rows=1545467 width=227) + predicate:(_col2 > _col3) + Merge Join Operator [MERGEJOIN_181] (rows=4636401 width=227) + Conds:RS_206._col1=RS_212._col1(Inner),Output:["_col0","_col2","_col3"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_212] + PartitionCols:_col1 + Select Operator [SEL_211] (rows=12 width=198) + Output:["_col0","_col1"] + Filter Operator [FIL_210] (rows=12 width=206) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_209] (rows=12 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 + Select Operator [SEL_208] (rows=5266632 width=201) + Output:["_col0","_col2"] + Group By Operator [GBY_207] (rows=5266632 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_45] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_199] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_176] (rows=8574602 width=112) - Conds:RS_192._col0=RS_196._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_196] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_195] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_192] - PartitionCols:_col0 - Select Operator [SEL_190] (rows=27657410 width=121) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_188] (rows=27657410 width=121) - predicate:(cr_returning_addr_sk is not null and cr_returning_customer_sk is not null and cr_returned_date_sk is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_62] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_175] (rows=1568628 width=1310) - Conds:RS_184._col2=RS_187._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_184] - PartitionCols:_col2 - Select Operator [SEL_183] (rows=80000000 width=375) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_182] (rows=80000000 width=375) - predicate:c_current_addr_sk is not null - TableScan [TS_0] (rows=80000000 width=375) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_187] - PartitionCols:_col0 - Select Operator [SEL_186] (rows=784314 width=941) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - Filter Operator [FIL_185] (rows=784314 width=1027) - predicate:(ca_state = 'IL') - TableScan [TS_3] (rows=40000000 width=1027) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_street_number","ca_street_name","ca_street_type","ca_suite_number","ca_city","ca_county","ca_state","ca_zip","ca_country","ca_gmt_offset","ca_location_type"] + Group By Operator [GBY_44] (rows=8749496 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_180] (rows=8749496 width=194) + Conds:RS_40._col2=RS_202._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_202] + PartitionCols:_col0 + Select Operator [SEL_200] (rows=40000000 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_199] (rows=40000000 width=90) + predicate:ca_state is not null + TableScan [TS_12] (rows=40000000 width=90) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_179] (rows=8749496 width=112) + Conds:RS_194._col0=RS_198._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_198] + PartitionCols:_col0 + Select Operator [SEL_196] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_195] (rows=652 width=8) + predicate:(d_year = 1998) + TableScan [TS_9] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_194] + PartitionCols:_col0 + Select Operator [SEL_192] (rows=28221532 width=121) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_190] (rows=28221532 width=121) + predicate:(cr_returning_addr_sk is not null and cr_returned_date_sk is not null) + TableScan [TS_6] (rows=28798881 width=121) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_returning_customer_sk","cr_returning_addr_sk","cr_return_amt_inc_tax"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_206] + PartitionCols:_col1 + Filter Operator [FIL_205] (rows=4636401 width=201) + predicate:_col2 is not null + Select Operator [SEL_204] (rows=4636401 width=201) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_203] (rows=4636401 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1 + Group By Operator [GBY_22] (rows=8574602 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_178] (rows=8574602 width=194) + Conds:RS_18._col2=RS_201._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_201] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_200] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_177] (rows=8574602 width=112) + Conds:RS_193._col0=RS_197._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_197] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_196] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_193] + PartitionCols:_col0 + Select Operator [SEL_191] (rows=27657410 width=121) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_189] (rows=27657410 width=121) + predicate:(cr_returning_addr_sk is not null and cr_returning_customer_sk is not null and cr_returned_date_sk is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_62] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_176] (rows=1568628 width=1310) + Conds:RS_185._col2=RS_188._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_185] + PartitionCols:_col2 + Select Operator [SEL_184] (rows=80000000 width=375) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_183] (rows=80000000 width=375) + predicate:c_current_addr_sk is not null + TableScan [TS_0] (rows=80000000 width=375) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_188] + PartitionCols:_col0 + Select Operator [SEL_187] (rows=784314 width=941) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] + Filter Operator [FIL_186] (rows=784314 width=1027) + predicate:(ca_state = 'IL') + TableScan [TS_3] (rows=40000000 width=1027) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_street_number","ca_street_name","ca_street_type","ca_suite_number","ca_city","ca_county","ca_state","ca_zip","ca_country","ca_gmt_offset","ca_location_type"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query82.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query82.q.out index 8dd6ae9f0f..c1d17eb803 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query82.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query82.q.out @@ -56,78 +56,78 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_100] - Limit [LIM_99] (rows=1 width=396) + File Output Operator [FS_105] + Limit [LIM_104] (rows=1 width=396) Number of rows:100 - Select Operator [SEL_98] (rows=1 width=396) + Select Operator [SEL_103] (rows=1 width=396) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - Group By Operator [GBY_96] (rows=1 width=396) + SHUFFLE [RS_102] + Group By Operator [GBY_101] (rows=1 width=396) Output:["_col0","_col1","_col2"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_23] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_22] (rows=2 width=396) Output:["_col0","_col1","_col2"],keys:_col2, _col3, _col4 - Top N Key Operator [TNK_42] (rows=11627 width=396) + Top N Key Operator [TNK_47] (rows=11627 width=396) keys:_col2, _col3, _col4,top n:100 - Merge Join Operator [MERGEJOIN_78] (rows=11627 width=396) + Merge Join Operator [MERGEJOIN_83] (rows=11627 width=396) Conds:RS_18._col1=RS_19._col1(Inner),Output:["_col2","_col3","_col4"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_76] (rows=3564040 width=400) - Conds:RS_89._col0=RS_81._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_81] (rows=3564040 width=400) + Conds:RS_94._col0=RS_86._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_81] + PARTITION_ONLY_SHUFFLE [RS_86] PartitionCols:_col0 - Select Operator [SEL_80] (rows=297 width=400) + Select Operator [SEL_85] (rows=297 width=400) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_79] (rows=297 width=404) + Filter Operator [FIL_84] (rows=297 width=404) predicate:(i_current_price BETWEEN 30 AND 60 and (i_manufact_id) IN (437, 129, 727, 663)) TableScan [TS_2] (rows=462000 width=403) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_manufact_id"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_89] + SHUFFLE [RS_94] PartitionCols:_col0 - Select Operator [SEL_88] (rows=575995635 width=4) + Select Operator [SEL_93] (rows=575995635 width=4) Output:["_col0"] - Filter Operator [FIL_87] (rows=575995635 width=4) + Filter Operator [FIL_92] (rows=575995635 width=4) predicate:(ss_item_sk BETWEEN DynamicValue(RS_16_item_i_item_sk_min) AND DynamicValue(RS_16_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_16_item_i_item_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=4) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_86] - Group By Operator [GBY_85] (rows=1 width=12) + BROADCAST [RS_91] + Group By Operator [GBY_90] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_84] - Group By Operator [GBY_83] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_89] + Group By Operator [GBY_88] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_82] (rows=297 width=4) + Select Operator [SEL_87] (rows=297 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_80] + Please refer to the previous Select Operator [SEL_85] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_77] (rows=1879072 width=4) - Conds:RS_92._col0=RS_95._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_82] (rows=1879072 width=4) + Conds:RS_97._col0=RS_100._col0(Inner),Output:["_col1"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_95] + SHUFFLE [RS_100] PartitionCols:_col0 - Select Operator [SEL_94] (rows=8116 width=4) + Select Operator [SEL_99] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_93] (rows=8116 width=98) + Filter Operator [FIL_98] (rows=8116 width=98) predicate:CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2002-05-30 00:00:00' AND TIMESTAMP'2002-07-29 00:00:00' TableScan [TS_8] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] + SHUFFLE [RS_97] PartitionCols:_col0 - Select Operator [SEL_91] (rows=16912800 width=8) + Select Operator [SEL_96] (rows=16912800 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_90] (rows=16912800 width=11) + Filter Operator [FIL_95] (rows=16912800 width=11) predicate:inv_quantity_on_hand BETWEEN 100 AND 500 TableScan [TS_5] (rows=37584000 width=11) default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_quantity_on_hand"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query83.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query83.q.out index a2163802ad..44a7ea15d4 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query83.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query83.q.out @@ -166,169 +166,171 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_398] - Limit [LIM_397] (rows=100 width=260) + File Output Operator [FS_399] + Limit [LIM_398] (rows=100 width=260) Number of rows:100 - Select Operator [SEL_396] (rows=2739 width=260) + Select Operator [SEL_397] (rows=2739 width=260) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_121] Select Operator [SEL_120] (rows=2739 width=260) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_363] (rows=2739 width=132) - Conds:RS_117._col0=RS_395._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6"] - <-Reducer 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_395] - PartitionCols:_col0 - Select Operator [SEL_394] (rows=310774 width=116) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_393] (rows=310774 width=108) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_111] - PartitionCols:_col0 - Group By Operator [GBY_110] (rows=1864644 width=108) - Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 - Merge Join Operator [MERGEJOIN_361] (rows=13749816 width=103) - Conds:RS_106._col4=RS_382._col0(Inner),Output:["_col5","_col7"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_382] - PartitionCols:_col0 - Select Operator [SEL_379] (rows=462000 width=104) - Output:["_col0","_col1"] - TableScan [TS_22] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_360] (rows=13749816 width=7) - Conds:RS_103._col0=RS_392._col0(Inner),Output:["_col4","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_103] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_351] (rows=2 width=4) - Conds:RS_366._col1=RS_375._col0(Inner),Output:["_col0"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_366] - PartitionCols:_col1 - Select Operator [SEL_365] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_364] (rows=73049 width=98) - predicate:d_date is not null - TableScan [TS_0] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_375] - PartitionCols:_col0 - Group By Operator [GBY_374] (rows=2 width=94) - Output:["_col0"],keys:KEY._col0 - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_16] - PartitionCols:_col0 - Group By Operator [GBY_15] (rows=2 width=94) - Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_350] (rows=5 width=94) - Conds:RS_369._col1=RS_373._col0(Left Semi),Output:["_col0"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_369] - PartitionCols:_col1 - Select Operator [SEL_368] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_367] (rows=73049 width=98) - predicate:(d_week_seq is not null and d_date is not null) - TableScan [TS_3] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] - <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_373] - PartitionCols:_col0 - Group By Operator [GBY_372] (rows=1 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_371] (rows=2 width=4) - Output:["_col0"] - Filter Operator [FIL_370] (rows=2 width=98) - predicate:((d_date) IN ('1998-01-02', '1998-10-15', '1998-11-10') and d_week_seq is not null) - TableScan [TS_6] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] - <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_392] - PartitionCols:_col0 - Select Operator [SEL_391] (rows=13749816 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_390] (rows=13749816 width=11) - predicate:wr_returned_date_sk is not null - TableScan [TS_95] (rows=14398467 width=11) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_item_sk","wr_return_quantity"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_117] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_362] (rows=2739 width=116) - Conds:RS_384._col0=RS_389._col0(Inner),Output:["_col0","_col1","_col3"] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_389] - PartitionCols:_col0 - Group By Operator [GBY_388] (rows=310774 width=108) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_73] - PartitionCols:_col0 - Group By Operator [GBY_72] (rows=7147802 width=108) - Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 - Merge Join Operator [MERGEJOIN_357] (rows=55578005 width=103) - Conds:RS_68._col4=RS_381._col0(Inner),Output:["_col5","_col7"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_381] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_379] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_68] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_356] (rows=55578005 width=7) - Conds:RS_65._col0=RS_387._col0(Inner),Output:["_col4","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_65] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_351] - <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_387] - PartitionCols:_col0 - Select Operator [SEL_386] (rows=55578005 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_385] (rows=55578005 width=11) - predicate:sr_returned_date_sk is not null - TableScan [TS_57] (rows=57591150 width=11) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_return_quantity"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_384] - PartitionCols:_col0 - Group By Operator [GBY_383] (rows=2739 width=108) + Top N Key Operator [TNK_207] (rows=2739 width=132) + keys:_col0, _col3,top n:100 + Merge Join Operator [MERGEJOIN_364] (rows=2739 width=132) + Conds:RS_117._col0=RS_396._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6"] + <-Reducer 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_396] + PartitionCols:_col0 + Select Operator [SEL_395] (rows=310774 width=116) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_394] (rows=310774 width=108) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_35] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_111] PartitionCols:_col0 - Group By Operator [GBY_34] (rows=2739 width=108) + Group By Operator [GBY_110] (rows=1864644 width=108) Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 - Merge Join Operator [MERGEJOIN_353] (rows=5478 width=100) - Conds:RS_30._col4=RS_380._col0(Inner),Output:["_col5","_col7"] + Merge Join Operator [MERGEJOIN_362] (rows=13749816 width=103) + Conds:RS_106._col4=RS_383._col0(Inner),Output:["_col5","_col7"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_380] + SHUFFLE [RS_383] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_379] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_30] + Select Operator [SEL_380] (rows=462000 width=104) + Output:["_col0","_col1"] + TableScan [TS_22] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_106] PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_352] (rows=5478 width=4) - Conds:RS_27._col0=RS_378._col0(Inner),Output:["_col4","_col5"] + Merge Join Operator [MERGEJOIN_361] (rows=13749816 width=7) + Conds:RS_103._col0=RS_393._col0(Inner),Output:["_col4","_col5"] <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_27] + SHUFFLE [RS_103] PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_351] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_378] + Merge Join Operator [MERGEJOIN_352] (rows=2 width=4) + Conds:RS_367._col1=RS_376._col0(Inner),Output:["_col0"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_367] + PartitionCols:_col1 + Select Operator [SEL_366] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_365] (rows=73049 width=98) + predicate:d_date is not null + TableScan [TS_0] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Reducer 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_376] + PartitionCols:_col0 + Group By Operator [GBY_375] (rows=2 width=94) + Output:["_col0"],keys:KEY._col0 + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_16] + PartitionCols:_col0 + Group By Operator [GBY_15] (rows=2 width=94) + Output:["_col0"],keys:_col0 + Merge Join Operator [MERGEJOIN_351] (rows=5 width=94) + Conds:RS_370._col1=RS_374._col0(Left Semi),Output:["_col0"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_370] + PartitionCols:_col1 + Select Operator [SEL_369] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_368] (rows=73049 width=98) + predicate:(d_week_seq is not null and d_date is not null) + TableScan [TS_3] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] + <-Map 18 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_374] + PartitionCols:_col0 + Group By Operator [GBY_373] (rows=1 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_372] (rows=2 width=4) + Output:["_col0"] + Filter Operator [FIL_371] (rows=2 width=98) + predicate:((d_date) IN ('1998-01-02', '1998-10-15', '1998-11-10') and d_week_seq is not null) + TableScan [TS_6] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] + <-Map 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_393] PartitionCols:_col0 - Select Operator [SEL_377] (rows=28798881 width=11) + Select Operator [SEL_392] (rows=13749816 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_376] (rows=28798881 width=11) - predicate:cr_returned_date_sk is not null - TableScan [TS_19] (rows=28798881 width=11) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_item_sk","cr_return_quantity"] + Filter Operator [FIL_391] (rows=13749816 width=11) + predicate:wr_returned_date_sk is not null + TableScan [TS_95] (rows=14398467 width=11) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_item_sk","wr_return_quantity"] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_117] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_363] (rows=2739 width=116) + Conds:RS_385._col0=RS_390._col0(Inner),Output:["_col0","_col1","_col3"] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_390] + PartitionCols:_col0 + Group By Operator [GBY_389] (rows=310774 width=108) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_73] + PartitionCols:_col0 + Group By Operator [GBY_72] (rows=7147802 width=108) + Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 + Merge Join Operator [MERGEJOIN_358] (rows=55578005 width=103) + Conds:RS_68._col4=RS_382._col0(Inner),Output:["_col5","_col7"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_382] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_380] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_68] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_357] (rows=55578005 width=7) + Conds:RS_65._col0=RS_388._col0(Inner),Output:["_col4","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_65] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_352] + <-Map 21 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_388] + PartitionCols:_col0 + Select Operator [SEL_387] (rows=55578005 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_386] (rows=55578005 width=11) + predicate:sr_returned_date_sk is not null + TableScan [TS_57] (rows=57591150 width=11) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_return_quantity"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_385] + PartitionCols:_col0 + Group By Operator [GBY_384] (rows=2739 width=108) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col0 + Group By Operator [GBY_34] (rows=2739 width=108) + Output:["_col0","_col1"],aggregations:["sum(_col5)"],keys:_col7 + Merge Join Operator [MERGEJOIN_354] (rows=5478 width=100) + Conds:RS_30._col4=RS_381._col0(Inner),Output:["_col5","_col7"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_381] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_380] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_353] (rows=5478 width=4) + Conds:RS_27._col0=RS_379._col0(Inner),Output:["_col4","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_352] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_379] + PartitionCols:_col0 + Select Operator [SEL_378] (rows=28798881 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_377] (rows=28798881 width=11) + predicate:cr_returned_date_sk is not null + TableScan [TS_19] (rows=28798881 width=11) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_item_sk","cr_return_quantity"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query84.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query84.q.out index 89b11e66e2..b520a2d6a7 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query84.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query84.q.out @@ -67,87 +67,89 @@ Stage-0 limit:-1 Stage-1 Reducer 5 vectorized - File Output Operator [FS_139] - Limit [LIM_138] (rows=100 width=384) + File Output Operator [FS_140] + Limit [LIM_139] (rows=100 width=384) Number of rows:100 - Select Operator [SEL_137] (rows=2645278 width=384) + Select Operator [SEL_138] (rows=2645278 width=384) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_35] Select Operator [SEL_34] (rows=2645278 width=384) Output:["_col1","_col2"] - Merge Join Operator [MERGEJOIN_119] (rows=2645278 width=284) - Conds:RS_31._col4=RS_32._col0(Inner),Output:["_col2","_col6"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_117] (rows=2161 width=4) - Conds:RS_133._col1=RS_136._col0(Inner),Output:["_col0"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_133] - PartitionCols:_col1 - Select Operator [SEL_132] (rows=7200 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_131] (rows=7200 width=8) - predicate:hd_income_band_sk is not null - TableScan [TS_15] (rows=7200 width=8) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_income_band_sk"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_136] - PartitionCols:_col0 - Select Operator [SEL_135] (rows=6 width=4) - Output:["_col0"] - Filter Operator [FIL_134] (rows=6 width=12) - predicate:((ib_lower_bound >= 32287) and (ib_upper_bound <= 82287)) - TableScan [TS_18] (rows=20 width=12) - default@income_band,income_band,Tbl:COMPLETE,Col:COMPLETE,Output:["ib_income_band_sk","ib_lower_bound","ib_upper_bound"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_118] (rows=2645278 width=287) - Conds:RS_28._col1=RS_29._col1(Inner),Output:["_col2","_col4","_col6"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_28] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_115] (rows=56363634 width=4) - Conds:RS_122._col0=RS_124._col0(Inner),Output:["_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_122] - PartitionCols:_col0 - Select Operator [SEL_121] (rows=55577698 width=3) - Output:["_col0"] - Filter Operator [FIL_120] (rows=55577698 width=3) - predicate:sr_cdemo_sk is not null - TableScan [TS_0] (rows=57591150 width=3) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_cdemo_sk"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_124] - PartitionCols:_col0 - Select Operator [SEL_123] (rows=1861800 width=4) - Output:["_col0"] - TableScan [TS_3] (rows=1861800 width=4) - default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_116] (rows=83148 width=284) - Conds:RS_127._col3=RS_130._col0(Inner),Output:["_col0","_col1","_col2","_col4"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_127] - PartitionCols:_col3 - Select Operator [SEL_126] (rows=74500295 width=295) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_125] (rows=74500295 width=291) - predicate:(c_current_hdemo_sk is not null and c_current_cdemo_sk is not null and c_current_addr_sk is not null) - TableScan [TS_5] (rows=80000000 width=291) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_id","c_current_cdemo_sk","c_current_hdemo_sk","c_current_addr_sk","c_first_name","c_last_name"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_130] - PartitionCols:_col0 - Select Operator [SEL_129] (rows=44643 width=4) - Output:["_col0"] - Filter Operator [FIL_128] (rows=44643 width=97) - predicate:(ca_city = 'Hopewell') - TableScan [TS_8] (rows=40000000 width=97) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] + Top N Key Operator [TNK_62] (rows=2645278 width=284) + keys:_col2,top n:100 + Merge Join Operator [MERGEJOIN_120] (rows=2645278 width=284) + Conds:RS_31._col4=RS_32._col0(Inner),Output:["_col2","_col6"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_118] (rows=2161 width=4) + Conds:RS_134._col1=RS_137._col0(Inner),Output:["_col0"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_134] + PartitionCols:_col1 + Select Operator [SEL_133] (rows=7200 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_132] (rows=7200 width=8) + predicate:hd_income_band_sk is not null + TableScan [TS_15] (rows=7200 width=8) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_income_band_sk"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_137] + PartitionCols:_col0 + Select Operator [SEL_136] (rows=6 width=4) + Output:["_col0"] + Filter Operator [FIL_135] (rows=6 width=12) + predicate:((ib_lower_bound >= 32287) and (ib_upper_bound <= 82287)) + TableScan [TS_18] (rows=20 width=12) + default@income_band,income_band,Tbl:COMPLETE,Col:COMPLETE,Output:["ib_income_band_sk","ib_lower_bound","ib_upper_bound"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_119] (rows=2645278 width=287) + Conds:RS_28._col1=RS_29._col1(Inner),Output:["_col2","_col4","_col6"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_28] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_116] (rows=56363634 width=4) + Conds:RS_123._col0=RS_125._col0(Inner),Output:["_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_123] + PartitionCols:_col0 + Select Operator [SEL_122] (rows=55577698 width=3) + Output:["_col0"] + Filter Operator [FIL_121] (rows=55577698 width=3) + predicate:sr_cdemo_sk is not null + TableScan [TS_0] (rows=57591150 width=3) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_cdemo_sk"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_125] + PartitionCols:_col0 + Select Operator [SEL_124] (rows=1861800 width=4) + Output:["_col0"] + TableScan [TS_3] (rows=1861800 width=4) + default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_117] (rows=83148 width=284) + Conds:RS_128._col3=RS_131._col0(Inner),Output:["_col0","_col1","_col2","_col4"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_128] + PartitionCols:_col3 + Select Operator [SEL_127] (rows=74500295 width=295) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_126] (rows=74500295 width=291) + predicate:(c_current_hdemo_sk is not null and c_current_cdemo_sk is not null and c_current_addr_sk is not null) + TableScan [TS_5] (rows=80000000 width=291) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_id","c_current_cdemo_sk","c_current_hdemo_sk","c_current_addr_sk","c_first_name","c_last_name"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_131] + PartitionCols:_col0 + Select Operator [SEL_130] (rows=44643 width=4) + Output:["_col0"] + Filter Operator [FIL_129] (rows=44643 width=97) + predicate:(ca_city = 'Hopewell') + TableScan [TS_8] (rows=40000000 width=97) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query85.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query85.q.out index 6bd833fd12..706bbd7807 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query85.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query85.q.out @@ -199,120 +199,122 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_207] - Limit [LIM_206] (rows=72 width=832) + File Output Operator [FS_209] + Limit [LIM_208] (rows=72 width=832) Number of rows:100 - Select Operator [SEL_205] (rows=72 width=832) + Select Operator [SEL_207] (rows=72 width=832) Output:["_col0","_col1","_col2","_col3"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_204] - Select Operator [SEL_203] (rows=72 width=832) + SHUFFLE [RS_206] + Select Operator [SEL_205] (rows=72 width=832) Output:["_col4","_col5","_col6","_col7"] - Group By Operator [GBY_202] (rows=72 width=353) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)"],keys:KEY._col0 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_43] - PartitionCols:_col0 - Group By Operator [GBY_42] (rows=576 width=353) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)","count(_col3)","sum(_col27)","count(_col27)","sum(_col26)","count(_col26)"],keys:_col36 - Merge Join Operator [MERGEJOIN_177] (rows=5749608 width=319) - Conds:RS_38._col24=RS_201._col0(Inner),Output:["_col3","_col26","_col27","_col36"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - PartitionCols:_col0 - Select Operator [SEL_200] (rows=72 width=101) - Output:["_col0","_col1"] - TableScan [TS_28] (rows=72 width=101) - default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_38] - PartitionCols:_col24 - Filter Operator [FIL_36] (rows=5749608 width=285) - predicate:(((_col29 and _col4) or (_col30 and _col5) or (_col31 and _col6)) and ((_col14 and _col15 and _col7) or (_col16 and _col17 and _col8) or (_col18 and _col19 and _col9))) - Merge Join Operator [MERGEJOIN_176] (rows=20443061 width=285) - Conds:RS_33._col1, _col2=RS_34._col9, _col14(Inner),Output:["_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col14","_col15","_col16","_col17","_col18","_col19","_col24","_col26","_col27","_col29","_col30","_col31"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col9, _col14 - Select Operator [SEL_27] (rows=2086007 width=213) - Output:["_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col13","_col14","_col15","_col16","_col18","_col19","_col20"] - Merge Join Operator [MERGEJOIN_175] (rows=2086007 width=213) - Conds:RS_24._col1, _col13, _col14=RS_198._col0, _col1, _col2(Inner),Output:["_col0","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col18","_col19","_col20","_col21","_col22","_col23"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] - PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_196] (rows=265971 width=207) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_195] (rows=265971 width=183) - predicate:((cd_marital_status) IN ('M', 'D', 'U') and (cd_education_status) IN ('4 yr Degree', 'Primary', 'Advanced Degree')) - TableScan [TS_15] (rows=1861800 width=183) - default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status","cd_education_status"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:_col1, _col13, _col14 - Merge Join Operator [MERGEJOIN_174] (rows=2086007 width=371) - Conds:RS_21._col3=RS_199._col0(Inner),Output:["_col0","_col1","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col13","_col14"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_199] - PartitionCols:_col0 - Select Operator [SEL_197] (rows=265971 width=183) - Output:["_col0","_col1","_col2"] - Please refer to the previous Filter Operator [FIL_195] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_173] (rows=11975292 width=245) - Conds:RS_191._col2=RS_194._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_194] - PartitionCols:_col0 - Select Operator [SEL_193] (rows=3529412 width=16) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_192] (rows=3529412 width=187) - predicate:((ca_state) IN ('KY', 'GA', 'NM', 'MT', 'OR', 'IN', 'WI', 'MO', 'WV') and (ca_country = 'United States')) - TableScan [TS_9] (rows=40000000 width=187) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_country"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] - PartitionCols:_col2 - Select Operator [SEL_190] (rows=11975292 width=237) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_189] (rows=11975292 width=237) - predicate:(wr_refunded_addr_sk is not null and wr_returning_cdemo_sk is not null and wr_refunded_cdemo_sk is not null and wr_reason_sk is not null) - TableScan [TS_6] (rows=14398467 width=237) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_refunded_cdemo_sk","wr_refunded_addr_sk","wr_returning_cdemo_sk","wr_reason_sk","wr_order_number","wr_fee","wr_refunded_cash"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_172] (rows=143931136 width=35) - Conds:RS_188._col0=RS_180._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_180] - PartitionCols:_col0 - Select Operator [SEL_179] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_178] (rows=652 width=8) - predicate:(d_year = 1998) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_188] - PartitionCols:_col0 - Select Operator [SEL_187] (rows=143931136 width=39) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Filter Operator [FIL_186] (rows=143931136 width=243) - predicate:(((ws_sales_price >= 100) or (ws_sales_price <= 150) or (ws_sales_price >= 50) or (ws_sales_price <= 100) or (ws_sales_price >= 150) or (ws_sales_price <= 200)) and ((ws_net_profit >= 100) or (ws_net_profit <= 200) or (ws_net_profit >= 150) or (ws_net_profit <= 300) or (ws_net_profit >= 50) or (ws_net_profit <= 250)) and ws_sold_date_sk is not null and ws_web_page_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_31_date_dim_d_date_sk_min) AND DynamicValue(RS_31_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_31_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=243) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_order_number","ws_quantity","ws_sales_price","ws_net_profit"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_185] - Group By Operator [GBY_184] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_183] - Group By Operator [GBY_182] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_181] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_179] + Top N Key Operator [TNK_204] (rows=72 width=353) + keys:substr(_col0, 1, 20), (UDFToDouble(_col1) / _col2), (_col3 / _col4), (_col5 / _col6),top n:100 + Group By Operator [GBY_203] (rows=72 width=353) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)"],keys:KEY._col0 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:_col0 + Group By Operator [GBY_42] (rows=576 width=353) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)","count(_col3)","sum(_col27)","count(_col27)","sum(_col26)","count(_col26)"],keys:_col36 + Merge Join Operator [MERGEJOIN_178] (rows=5749608 width=319) + Conds:RS_38._col24=RS_202._col0(Inner),Output:["_col3","_col26","_col27","_col36"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_202] + PartitionCols:_col0 + Select Operator [SEL_201] (rows=72 width=101) + Output:["_col0","_col1"] + TableScan [TS_28] (rows=72 width=101) + default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_38] + PartitionCols:_col24 + Filter Operator [FIL_36] (rows=5749608 width=285) + predicate:(((_col29 and _col4) or (_col30 and _col5) or (_col31 and _col6)) and ((_col14 and _col15 and _col7) or (_col16 and _col17 and _col8) or (_col18 and _col19 and _col9))) + Merge Join Operator [MERGEJOIN_177] (rows=20443061 width=285) + Conds:RS_33._col1, _col2=RS_34._col9, _col14(Inner),Output:["_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col14","_col15","_col16","_col17","_col18","_col19","_col24","_col26","_col27","_col29","_col30","_col31"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col9, _col14 + Select Operator [SEL_27] (rows=2086007 width=213) + Output:["_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col13","_col14","_col15","_col16","_col18","_col19","_col20"] + Merge Join Operator [MERGEJOIN_176] (rows=2086007 width=213) + Conds:RS_24._col1, _col13, _col14=RS_199._col0, _col1, _col2(Inner),Output:["_col0","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col18","_col19","_col20","_col21","_col22","_col23"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_199] + PartitionCols:_col0, _col1, _col2 + Select Operator [SEL_197] (rows=265971 width=207) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_196] (rows=265971 width=183) + predicate:((cd_marital_status) IN ('M', 'D', 'U') and (cd_education_status) IN ('4 yr Degree', 'Primary', 'Advanced Degree')) + TableScan [TS_15] (rows=1861800 width=183) + default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status","cd_education_status"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col1, _col13, _col14 + Merge Join Operator [MERGEJOIN_175] (rows=2086007 width=371) + Conds:RS_21._col3=RS_200._col0(Inner),Output:["_col0","_col1","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col13","_col14"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_200] + PartitionCols:_col0 + Select Operator [SEL_198] (rows=265971 width=183) + Output:["_col0","_col1","_col2"] + Please refer to the previous Filter Operator [FIL_196] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_174] (rows=11975292 width=245) + Conds:RS_192._col2=RS_195._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_195] + PartitionCols:_col0 + Select Operator [SEL_194] (rows=3529412 width=16) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_193] (rows=3529412 width=187) + predicate:((ca_state) IN ('KY', 'GA', 'NM', 'MT', 'OR', 'IN', 'WI', 'MO', 'WV') and (ca_country = 'United States')) + TableScan [TS_9] (rows=40000000 width=187) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_country"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_192] + PartitionCols:_col2 + Select Operator [SEL_191] (rows=11975292 width=237) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_190] (rows=11975292 width=237) + predicate:(wr_refunded_addr_sk is not null and wr_returning_cdemo_sk is not null and wr_refunded_cdemo_sk is not null and wr_reason_sk is not null) + TableScan [TS_6] (rows=14398467 width=237) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_refunded_cdemo_sk","wr_refunded_addr_sk","wr_returning_cdemo_sk","wr_reason_sk","wr_order_number","wr_fee","wr_refunded_cash"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_173] (rows=143931136 width=35) + Conds:RS_189._col0=RS_181._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_181] + PartitionCols:_col0 + Select Operator [SEL_180] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_179] (rows=652 width=8) + predicate:(d_year = 1998) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_189] + PartitionCols:_col0 + Select Operator [SEL_188] (rows=143931136 width=39) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] + Filter Operator [FIL_187] (rows=143931136 width=243) + predicate:(((ws_sales_price >= 100) or (ws_sales_price <= 150) or (ws_sales_price >= 50) or (ws_sales_price <= 100) or (ws_sales_price >= 150) or (ws_sales_price <= 200)) and ((ws_net_profit >= 100) or (ws_net_profit <= 200) or (ws_net_profit >= 150) or (ws_net_profit <= 300) or (ws_net_profit >= 50) or (ws_net_profit <= 250)) and ws_sold_date_sk is not null and ws_web_page_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_31_date_dim_d_date_sk_min) AND DynamicValue(RS_31_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_31_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=243) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_order_number","ws_quantity","ws_sales_price","ws_net_profit"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_186] + Group By Operator [GBY_185] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_184] + Group By Operator [GBY_183] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_182] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_180] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query86.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query86.q.out index 0b6ee2c156..47281f9f97 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query86.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query86.q.out @@ -72,74 +72,76 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_82] - Limit [LIM_81] (rows=100 width=490) + File Output Operator [FS_84] + Limit [LIM_83] (rows=100 width=490) Number of rows:100 - Select Operator [SEL_80] (rows=3060 width=490) + Select Operator [SEL_82] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_79] - Select Operator [SEL_78] (rows=3060 width=490) + SHUFFLE [RS_81] + Select Operator [SEL_80] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_77] (rows=3060 width=302) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] - Select Operator [SEL_76] (rows=3060 width=302) - Output:["_col0","_col1","_col2","_col3"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_75] - PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END - Select Operator [SEL_74] (rows=3060 width=302) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_73] (rows=3060 width=302) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_16] (rows=507960 width=302) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L - Select Operator [SEL_14] (rows=143966864 width=293) - Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_59] (rows=143966864 width=293) - Conds:RS_11._col1=RS_72._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_72] - PartitionCols:_col0 - Select Operator [SEL_71] (rows=462000 width=186) - Output:["_col0","_col1","_col2"] - TableScan [TS_6] (rows=462000 width=186) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_58] (rows=143966864 width=115) - Conds:RS_70._col0=RS_62._col0(Inner),Output:["_col1","_col2"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_62] - PartitionCols:_col0 - Select Operator [SEL_61] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_60] (rows=317 width=8) - predicate:d_month_seq BETWEEN 1212 AND 1223 - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_70] - PartitionCols:_col0 - Select Operator [SEL_69] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_68] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_d1_d_date_sk_min) AND DynamicValue(RS_9_d1_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_net_paid"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_67] - Group By Operator [GBY_66] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_65] - Group By Operator [GBY_64] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_63] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_61] + Top N Key Operator [TNK_79] (rows=3060 width=302) + keys:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN (((grouping(_col3, 1L) + grouping(_col3, 0L)) = 0L)) THEN (_col0) ELSE (null) END, rank_window_0,top n:100 + PTF Operator [PTF_78] (rows=3060 width=302) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] + Select Operator [SEL_77] (rows=3060 width=302) + Output:["_col0","_col1","_col2","_col3"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_76] + PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END + Select Operator [SEL_75] (rows=3060 width=302) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_74] (rows=3060 width=302) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_16] (rows=507960 width=302) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L + Select Operator [SEL_14] (rows=143966864 width=293) + Output:["_col0","_col1","_col2"] + Merge Join Operator [MERGEJOIN_60] (rows=143966864 width=293) + Conds:RS_11._col1=RS_73._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_73] + PartitionCols:_col0 + Select Operator [SEL_72] (rows=462000 width=186) + Output:["_col0","_col1","_col2"] + TableScan [TS_6] (rows=462000 width=186) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_59] (rows=143966864 width=115) + Conds:RS_71._col0=RS_63._col0(Inner),Output:["_col1","_col2"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_62] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_61] (rows=317 width=8) + predicate:d_month_seq BETWEEN 1212 AND 1223 + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_71] + PartitionCols:_col0 + Select Operator [SEL_70] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_69] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_9_d1_d_date_sk_min) AND DynamicValue(RS_9_d1_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_9_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_net_paid"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_68] + Group By Operator [GBY_67] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_66] + Group By Operator [GBY_65] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_64] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_62] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query89.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query89.q.out index 28d604a433..e216e914ad 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query89.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query89.q.out @@ -79,88 +79,90 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_110] - Limit [LIM_109] (rows=100 width=801) + File Output Operator [FS_112] + Limit [LIM_111] (rows=100 width=801) Number of rows:100 - Select Operator [SEL_108] (rows=181038 width=801) + Select Operator [SEL_110] (rows=181038 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_107] - Select Operator [SEL_106] (rows=181038 width=801) + SHUFFLE [RS_109] + Select Operator [SEL_108] (rows=181038 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_105] (rows=181038 width=689) - predicate:CASE WHEN ((avg_window_0 <> 0)) THEN (((abs((_col6 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END - Select Operator [SEL_104] (rows=362076 width=577) - Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_103] (rows=362076 width=577) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS FIRST","partition by:":"_col2, _col0, _col4, _col5"}] - Select Operator [SEL_102] (rows=362076 width=577) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_101] - PartitionCols:_col2, _col0, _col4, _col5 - Group By Operator [GBY_100] (rows=362076 width=577) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_21] (rows=76480702 width=577) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col7, _col9, _col11, _col12 - Merge Join Operator [MERGEJOIN_83] (rows=76480702 width=542) - Conds:RS_17._col2=RS_99._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_99] - PartitionCols:_col0 - Select Operator [SEL_98] (rows=1704 width=183) - Output:["_col0","_col1","_col2"] - TableScan [TS_9] (rows=1704 width=183) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_82] (rows=76480702 width=366) - Conds:RS_14._col0=RS_86._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col7","_col9"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_86] - PartitionCols:_col0 - Select Operator [SEL_85] (rows=652 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_84] (rows=652 width=12) - predicate:(d_year = 2000) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_14] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_81] (rows=76480702 width=364) - Conds:RS_94._col1=RS_97._col0(Inner),Output:["_col0","_col2","_col3","_col5","_col6","_col7"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_94] - PartitionCols:_col1 - Select Operator [SEL_93] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_92] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_91] - Group By Operator [GBY_90] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_89] - Group By Operator [GBY_88] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_87] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_85] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - PartitionCols:_col0 - Select Operator [SEL_96] (rows=6988 width=286) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_95] (rows=6988 width=286) - predicate:((i_class) IN ('wallpaper', 'parenting', 'musical', 'womens', 'birdal', 'pants') and (i_category) IN ('Home', 'Books', 'Electronics', 'Shoes', 'Jewelry', 'Men') and (((i_category) IN ('Home', 'Books', 'Electronics') and (i_class) IN ('wallpaper', 'parenting', 'musical')) or ((i_category) IN ('Shoes', 'Jewelry', 'Men') and (i_class) IN ('womens', 'birdal', 'pants')))) - TableScan [TS_3] (rows=462000 width=286) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category"] + Top N Key Operator [TNK_107] (rows=181038 width=689) + keys:(_col6 - avg_window_0), _col4,top n:100 + Filter Operator [FIL_106] (rows=181038 width=689) + predicate:CASE WHEN ((avg_window_0 <> 0)) THEN (((abs((_col6 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END + Select Operator [SEL_105] (rows=362076 width=577) + Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + PTF Operator [PTF_104] (rows=362076 width=577) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS FIRST","partition by:":"_col2, _col0, _col4, _col5"}] + Select Operator [SEL_103] (rows=362076 width=577) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_102] + PartitionCols:_col2, _col0, _col4, _col5 + Group By Operator [GBY_101] (rows=362076 width=577) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_21] (rows=76480702 width=577) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col7, _col9, _col11, _col12 + Merge Join Operator [MERGEJOIN_84] (rows=76480702 width=542) + Conds:RS_17._col2=RS_100._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_100] + PartitionCols:_col0 + Select Operator [SEL_99] (rows=1704 width=183) + Output:["_col0","_col1","_col2"] + TableScan [TS_9] (rows=1704 width=183) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_83] (rows=76480702 width=366) + Conds:RS_14._col0=RS_87._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col7","_col9"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_87] + PartitionCols:_col0 + Select Operator [SEL_86] (rows=652 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_85] (rows=652 width=12) + predicate:(d_year = 2000) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_14] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_82] (rows=76480702 width=364) + Conds:RS_95._col1=RS_98._col0(Inner),Output:["_col0","_col2","_col3","_col5","_col6","_col7"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_95] + PartitionCols:_col1 + Select Operator [SEL_94] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_93] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_92] + Group By Operator [GBY_91] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_90] + Group By Operator [GBY_89] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_88] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_86] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_98] + PartitionCols:_col0 + Select Operator [SEL_97] (rows=6988 width=286) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_96] (rows=6988 width=286) + predicate:((i_class) IN ('wallpaper', 'parenting', 'musical', 'womens', 'birdal', 'pants') and (i_category) IN ('Home', 'Books', 'Electronics', 'Shoes', 'Jewelry', 'Men') and (((i_category) IN ('Home', 'Books', 'Electronics') and (i_class) IN ('wallpaper', 'parenting', 'musical')) or ((i_category) IN ('Shoes', 'Jewelry', 'Men') and (i_class) IN ('womens', 'birdal', 'pants')))) + TableScan [TS_3] (rows=462000 width=286) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query93.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query93.q.out index 193a542b53..6b76bb2cb0 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query93.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query93.q.out @@ -53,52 +53,54 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_76] - Limit [LIM_75] (rows=100 width=115) + File Output Operator [FS_78] + Limit [LIM_77] (rows=100 width=115) Number of rows:100 - Select Operator [SEL_74] (rows=1398474 width=115) + Select Operator [SEL_76] (rows=1398474 width=115) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_73] - Group By Operator [GBY_72] (rows=1398474 width=115) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0 - Group By Operator [GBY_16] (rows=569016747 width=115) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Select Operator [SEL_14] (rows=569016747 width=118) - Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_63] (rows=569016747 width=118) - Conds:RS_11._col0, _col2=RS_71._col0, _col2(Inner),Output:["_col3","_col6","_col8","_col9"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - PartitionCols:_col0, _col2 - Select Operator [SEL_70] (rows=575995635 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - TableScan [TS_6] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_sales_price"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col0, _col2 - Merge Join Operator [MERGEJOIN_62] (rows=55574563 width=11) - Conds:RS_66._col1=RS_69._col0(Inner),Output:["_col0","_col2","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_66] - PartitionCols:_col1 - Select Operator [SEL_65] (rows=55574563 width=15) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_64] (rows=55574563 width=15) - predicate:sr_reason_sk is not null - TableScan [TS_0] (rows=57591150 width=15) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_reason_sk","sr_ticket_number","sr_return_quantity"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=1 width=4) - Output:["_col0"] - Filter Operator [FIL_67] (rows=1 width=101) - predicate:(r_reason_desc = 'Did not like the warranty') - TableScan [TS_3] (rows=72 width=101) - default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] + SHUFFLE [RS_75] + Top N Key Operator [TNK_74] (rows=1398474 width=115) + keys:_col1, _col0,top n:100 + Group By Operator [GBY_73] (rows=1398474 width=115) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0 + Group By Operator [GBY_16] (rows=569016747 width=115) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Select Operator [SEL_14] (rows=569016747 width=118) + Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_64] (rows=569016747 width=118) + Conds:RS_11._col0, _col2=RS_72._col0, _col2(Inner),Output:["_col3","_col6","_col8","_col9"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_72] + PartitionCols:_col0, _col2 + Select Operator [SEL_71] (rows=575995635 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + TableScan [TS_6] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_sales_price"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col0, _col2 + Merge Join Operator [MERGEJOIN_63] (rows=55574563 width=11) + Conds:RS_67._col1=RS_70._col0(Inner),Output:["_col0","_col2","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_67] + PartitionCols:_col1 + Select Operator [SEL_66] (rows=55574563 width=15) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_65] (rows=55574563 width=15) + predicate:sr_reason_sk is not null + TableScan [TS_0] (rows=57591150 width=15) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_reason_sk","sr_ticket_number","sr_return_quantity"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_70] + PartitionCols:_col0 + Select Operator [SEL_69] (rows=1 width=4) + Output:["_col0"] + Filter Operator [FIL_68] (rows=1 width=101) + predicate:(r_reason_desc = 'Did not like the warranty') + TableScan [TS_3] (rows=72 width=101) + default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] diff --git ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out index c77a73f4d5..53102977dd 100644 --- ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out +++ ql/src/test/results/clientpositive/perf/tez/constraints/query99.q.out @@ -95,88 +95,88 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_120] - Limit [LIM_119] (rows=100 width=590) + File Output Operator [FS_125] + Limit [LIM_124] (rows=100 width=590) Number of rows:100 - Select Operator [SEL_118] (rows=3920468 width=590) + Select Operator [SEL_123] (rows=3920468 width=590) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] - Select Operator [SEL_116] (rows=3920468 width=590) + SHUFFLE [RS_122] + Select Operator [SEL_121] (rows=3920468 width=590) Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Group By Operator [GBY_115] (rows=3920468 width=406) + Group By Operator [GBY_120] (rows=3920468 width=406) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_25] (rows=7840936 width=406) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col13, _col11, _col15 - Top N Key Operator [TNK_53] (rows=15681873 width=386) + Top N Key Operator [TNK_56] (rows=15681873 width=386) keys:_col13, _col11, _col15,top n:100 - Merge Join Operator [MERGEJOIN_97] (rows=15681873 width=386) - Conds:RS_21._col1=RS_114._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col8","_col11","_col13","_col15"] + Merge Join Operator [MERGEJOIN_102] (rows=15681873 width=386) + Conds:RS_21._col1=RS_119._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col8","_col11","_col13","_col15"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_114] + SHUFFLE [RS_119] PartitionCols:_col0 - Select Operator [SEL_113] (rows=60 width=102) + Select Operator [SEL_118] (rows=60 width=102) Output:["_col0","_col1"] TableScan [TS_10] (rows=60 width=102) default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_96] (rows=15681873 width=291) - Conds:RS_18._col3=RS_112._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col8","_col11","_col13"] + Merge Join Operator [MERGEJOIN_101] (rows=15681873 width=291) + Conds:RS_18._col3=RS_117._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col8","_col11","_col13"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_112] + SHUFFLE [RS_117] PartitionCols:_col0 - Select Operator [SEL_111] (rows=27 width=188) + Select Operator [SEL_116] (rows=27 width=188) Output:["_col0","_col1"] TableScan [TS_8] (rows=27 width=104) default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_95] (rows=15681873 width=111) - Conds:RS_15._col2=RS_99._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] + Merge Join Operator [MERGEJOIN_100] (rows=15681873 width=111) + Conds:RS_15._col2=RS_104._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_99] + SHUFFLE [RS_104] PartitionCols:_col0 - Select Operator [SEL_98] (rows=1 width=88) + Select Operator [SEL_103] (rows=1 width=88) Output:["_col0","_col1"] TableScan [TS_6] (rows=1 width=88) default@ship_mode,ship_mode,Tbl:COMPLETE,Col:COMPLETE,Output:["sm_ship_mode_sk","sm_type"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_15] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_94] (rows=282273729 width=31) - Conds:RS_107._col0=RS_110._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_99] (rows=282273729 width=31) + Conds:RS_112._col0=RS_115._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_107] + SHUFFLE [RS_112] PartitionCols:_col0 - Select Operator [SEL_106] (rows=282273729 width=35) + Select Operator [SEL_111] (rows=282273729 width=35) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_105] (rows=282273729 width=19) + Filter Operator [FIL_110] (rows=282273729 width=19) predicate:(cs_warehouse_sk is not null and cs_ship_date_sk is not null and cs_ship_mode_sk is not null and cs_call_center_sk is not null and cs_ship_mode_sk BETWEEN DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_min) AND DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_max) and in_bloom_filter(cs_ship_mode_sk, DynamicValue(RS_16_ship_mode_sm_ship_mode_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=19) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_call_center_sk","cs_ship_mode_sk","cs_warehouse_sk"] <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_104] - Group By Operator [GBY_103] (rows=1 width=12) + BROADCAST [RS_109] + Group By Operator [GBY_108] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_102] - Group By Operator [GBY_101] (rows=1 width=12) + SHUFFLE [RS_107] + Group By Operator [GBY_106] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_100] (rows=1 width=4) + Select Operator [SEL_105] (rows=1 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_98] + Please refer to the previous Select Operator [SEL_103] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_110] + SHUFFLE [RS_115] PartitionCols:_col0 - Select Operator [SEL_109] (rows=317 width=4) + Select Operator [SEL_114] (rows=317 width=4) Output:["_col0"] - Filter Operator [FIL_108] (rows=317 width=8) + Filter Operator [FIL_113] (rows=317 width=8) predicate:d_month_seq BETWEEN 1212 AND 1223 TableScan [TS_3] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] diff --git ql/src/test/results/clientpositive/perf/tez/query1.q.out ql/src/test/results/clientpositive/perf/tez/query1.q.out index f7affa4f14..63b631377c 100644 --- ql/src/test/results/clientpositive/perf/tez/query1.q.out +++ ql/src/test/results/clientpositive/perf/tez/query1.q.out @@ -73,111 +73,113 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_165] - Limit [LIM_164] (rows=100 width=100) + File Output Operator [FS_166] + Limit [LIM_165] (rows=100 width=100) Number of rows:100 - Select Operator [SEL_163] (rows=17457727 width=100) + Select Operator [SEL_164] (rows=17457727 width=100) Output:["_col0"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_52] Select Operator [SEL_51] (rows=17457727 width=100) Output:["_col0"] - Filter Operator [FIL_50] (rows=17457727 width=324) - predicate:(_col3 > _col6) - Merge Join Operator [MERGEJOIN_136] (rows=52373181 width=324) - Conds:RS_47._col2=RS_162._col1(Inner),Output:["_col3","_col5","_col6"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_162] - PartitionCols:_col1 - Select Operator [SEL_161] (rows=85 width=115) - Output:["_col0","_col1"] - Filter Operator [FIL_160] (rows=85 width=123) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_159] (rows=85 width=123) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 - Select Operator [SEL_158] (rows=53634860 width=119) - Output:["_col1","_col2"] - Group By Operator [GBY_157] (rows=53634860 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col0 - Group By Operator [GBY_31] (rows=53634860 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_135] (rows=53634860 width=115) - Conds:RS_145._col0=RS_149._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_149] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_146] (rows=652 width=8) - predicate:((d_year = 2000) and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_145] - PartitionCols:_col0 - Select Operator [SEL_143] (rows=53634860 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_141] (rows=53634860 width=119) - predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) - TableScan [TS_3] (rows=57591150 width=119) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_customer_sk","sr_store_sk","sr_fee"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_47] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_134] (rows=51757026 width=215) - Conds:RS_44._col1=RS_156._col0(Inner),Output:["_col2","_col3","_col5"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_156] - PartitionCols:_col0 - Select Operator [SEL_155] (rows=80000000 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_154] (rows=80000000 width=104) - predicate:c_customer_sk is not null - TableScan [TS_18] (rows=80000000 width=104) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_44] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_133] (rows=51757026 width=119) - Conds:RS_139._col0=RS_153._col1(Inner),Output:["_col1","_col2","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_139] - PartitionCols:_col0 - Select Operator [SEL_138] (rows=35 width=4) - Output:["_col0"] - Filter Operator [FIL_137] (rows=35 width=90) - predicate:((s_state = 'NM') and s_store_sk is not null) - TableScan [TS_0] (rows=1704 width=90) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_153] - PartitionCols:_col1 - Select Operator [SEL_152] (rows=51757026 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_151] (rows=51757026 width=119) - predicate:_col2 is not null - Group By Operator [GBY_150] (rows=51757026 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_14] - PartitionCols:_col0, _col1 - Group By Operator [GBY_13] (rows=51757026 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_132] (rows=51757026 width=115) - Conds:RS_144._col0=RS_148._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_147] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] - PartitionCols:_col0 - Select Operator [SEL_142] (rows=51757026 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_140] (rows=51757026 width=119) - predicate:(sr_customer_sk is not null and sr_store_sk is not null and sr_returned_date_sk is not null) - Please refer to the previous TableScan [TS_3] + Top N Key Operator [TNK_79] (rows=17457727 width=324) + keys:_col5,top n:100 + Filter Operator [FIL_50] (rows=17457727 width=324) + predicate:(_col3 > _col6) + Merge Join Operator [MERGEJOIN_137] (rows=52373181 width=324) + Conds:RS_47._col2=RS_163._col1(Inner),Output:["_col3","_col5","_col6"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_163] + PartitionCols:_col1 + Select Operator [SEL_162] (rows=85 width=115) + Output:["_col0","_col1"] + Filter Operator [FIL_161] (rows=85 width=123) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_160] (rows=85 width=123) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 + Select Operator [SEL_159] (rows=53634860 width=119) + Output:["_col1","_col2"] + Group By Operator [GBY_158] (rows=53634860 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col0 + Group By Operator [GBY_31] (rows=53634860 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_136] (rows=53634860 width=115) + Conds:RS_146._col0=RS_150._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_150] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_147] (rows=652 width=8) + predicate:((d_year = 2000) and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_146] + PartitionCols:_col0 + Select Operator [SEL_144] (rows=53634860 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_142] (rows=53634860 width=119) + predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) + TableScan [TS_3] (rows=57591150 width=119) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_customer_sk","sr_store_sk","sr_fee"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_47] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_135] (rows=51757026 width=215) + Conds:RS_44._col1=RS_157._col0(Inner),Output:["_col2","_col3","_col5"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_157] + PartitionCols:_col0 + Select Operator [SEL_156] (rows=80000000 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_155] (rows=80000000 width=104) + predicate:c_customer_sk is not null + TableScan [TS_18] (rows=80000000 width=104) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_44] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_134] (rows=51757026 width=119) + Conds:RS_140._col0=RS_154._col1(Inner),Output:["_col1","_col2","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_140] + PartitionCols:_col0 + Select Operator [SEL_139] (rows=35 width=4) + Output:["_col0"] + Filter Operator [FIL_138] (rows=35 width=90) + predicate:((s_state = 'NM') and s_store_sk is not null) + TableScan [TS_0] (rows=1704 width=90) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_154] + PartitionCols:_col1 + Select Operator [SEL_153] (rows=51757026 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_152] (rows=51757026 width=119) + predicate:_col2 is not null + Group By Operator [GBY_151] (rows=51757026 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_14] + PartitionCols:_col0, _col1 + Group By Operator [GBY_13] (rows=51757026 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_133] (rows=51757026 width=115) + Conds:RS_145._col0=RS_149._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_148] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_145] + PartitionCols:_col0 + Select Operator [SEL_143] (rows=51757026 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_141] (rows=51757026 width=119) + predicate:(sr_customer_sk is not null and sr_store_sk is not null and sr_returned_date_sk is not null) + Please refer to the previous TableScan [TS_3] diff --git ql/src/test/results/clientpositive/perf/tez/query10.q.out ql/src/test/results/clientpositive/perf/tez/query10.q.out index b346a5c5fb..0b332453d9 100644 --- ql/src/test/results/clientpositive/perf/tez/query10.q.out +++ ql/src/test/results/clientpositive/perf/tez/query10.q.out @@ -157,120 +157,120 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_231] - Limit [LIM_230] (rows=1 width=419) + File Output Operator [FS_236] + Limit [LIM_235] (rows=1 width=419) Number of rows:100 - Select Operator [SEL_229] (rows=1 width=419) + Select Operator [SEL_234] (rows=1 width=419) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_228] - Select Operator [SEL_227] (rows=1 width=419) + SHUFFLE [RS_233] + Select Operator [SEL_232] (rows=1 width=419) Output:["_col0","_col1","_col2","_col3","_col4","_col6","_col8","_col10","_col12"] - Group By Operator [GBY_226] (rows=1 width=379) + Group By Operator [GBY_231] (rows=1 width=379) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Group By Operator [GBY_66] (rows=3 width=379) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["count()"],keys:_col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13 - Top N Key Operator [TNK_103] (rows=1401496 width=379) - keys:_col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13,top n:100 - Select Operator [SEL_65] (rows=1401496 width=379) - Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Select Operator [SEL_65] (rows=1401496 width=379) + Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Top N Key Operator [TNK_106] (rows=1401496 width=379) + keys:_col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13,top n:100 Filter Operator [FIL_64] (rows=1401496 width=379) predicate:(_col14 is not null or _col16 is not null) - Merge Join Operator [MERGEJOIN_181] (rows=1401496 width=379) - Conds:RS_61._col0=RS_225._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col16"] + Merge Join Operator [MERGEJOIN_186] (rows=1401496 width=379) + Conds:RS_61._col0=RS_230._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col16"] <-Reducer 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] + SHUFFLE [RS_230] PartitionCols:_col1 - Select Operator [SEL_224] (rows=1401496 width=7) + Select Operator [SEL_229] (rows=1401496 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_223] (rows=1401496 width=3) + Group By Operator [GBY_228] (rows=1401496 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 18 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col0 Group By Operator [GBY_43] (rows=285115246 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=285115246 width=3) - Conds:RS_222._col0=RS_197._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_183] (rows=285115246 width=3) + Conds:RS_227._col0=RS_202._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_197] + PARTITION_ONLY_SHUFFLE [RS_202] PartitionCols:_col0 - Select Operator [SEL_192] (rows=201 width=4) + Select Operator [SEL_197] (rows=201 width=4) Output:["_col0"] - Filter Operator [FIL_191] (rows=201 width=12) + Filter Operator [FIL_196] (rows=201 width=12) predicate:((d_year = 2002) and d_moy BETWEEN 4 AND 7 and d_date_sk is not null) TableScan [TS_12] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_222] + SHUFFLE [RS_227] PartitionCols:_col0 - Select Operator [SEL_221] (rows=285115246 width=7) + Select Operator [SEL_226] (rows=285115246 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_220] (rows=285115246 width=7) + Filter Operator [FIL_225] (rows=285115246 width=7) predicate:(cs_ship_customer_sk is not null and cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_40_date_dim_d_date_sk_min) AND DynamicValue(RS_40_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_40_date_dim_d_date_sk_bloom_filter))) TableScan [TS_33] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"] <-Reducer 20 [BROADCAST_EDGE] vectorized - BROADCAST [RS_219] - Group By Operator [GBY_218] (rows=1 width=12) + BROADCAST [RS_224] + Group By Operator [GBY_223] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_204] - Group By Operator [GBY_201] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_209] + Group By Operator [GBY_206] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_198] (rows=201 width=4) + Select Operator [SEL_203] (rows=201 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_192] + Please refer to the previous Select Operator [SEL_197] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_61] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_180] (rows=1414922 width=379) - Conds:RS_58._col0=RS_217._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] + Merge Join Operator [MERGEJOIN_185] (rows=1414922 width=379) + Conds:RS_58._col0=RS_222._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_217] + SHUFFLE [RS_222] PartitionCols:_col1 - Select Operator [SEL_216] (rows=1414922 width=7) + Select Operator [SEL_221] (rows=1414922 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_215] (rows=1414922 width=3) + Group By Operator [GBY_220] (rows=1414922 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0 Group By Operator [GBY_29] (rows=143930993 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_177] (rows=143930993 width=3) - Conds:RS_214._col0=RS_195._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_182] (rows=143930993 width=3) + Conds:RS_219._col0=RS_200._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_195] + PARTITION_ONLY_SHUFFLE [RS_200] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_192] + Please refer to the previous Select Operator [SEL_197] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_214] + SHUFFLE [RS_219] PartitionCols:_col0 - Select Operator [SEL_213] (rows=143930993 width=7) + Select Operator [SEL_218] (rows=143930993 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_212] (rows=143930993 width=7) + Filter Operator [FIL_217] (rows=143930993 width=7) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_26_date_dim_d_date_sk_min) AND DynamicValue(RS_26_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_26_date_dim_d_date_sk_bloom_filter))) TableScan [TS_19] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"] <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_211] - Group By Operator [GBY_210] (rows=1 width=12) + BROADCAST [RS_216] + Group By Operator [GBY_215] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_203] - Group By Operator [GBY_200] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_208] + Group By Operator [GBY_205] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_196] (rows=201 width=4) + Select Operator [SEL_201] (rows=201 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_192] + Please refer to the previous Select Operator [SEL_197] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_58] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_179] (rows=525327388 width=375) + Merge Join Operator [MERGEJOIN_184] (rows=525327388 width=375) Conds:RS_55._col0=RS_56._col0(Left Semi),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_56] @@ -279,66 +279,66 @@ Stage-0 Output:["_col0"],keys:_col0 Select Operator [SEL_18] (rows=525327388 width=3) Output:["_col0"] - Merge Join Operator [MERGEJOIN_176] (rows=525327388 width=3) - Conds:RS_209._col0=RS_193._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_181] (rows=525327388 width=3) + Conds:RS_214._col0=RS_198._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_193] + PARTITION_ONLY_SHUFFLE [RS_198] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_192] + Please refer to the previous Select Operator [SEL_197] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_209] + SHUFFLE [RS_214] PartitionCols:_col0 - Select Operator [SEL_208] (rows=525327388 width=7) + Select Operator [SEL_213] (rows=525327388 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_207] (rows=525327388 width=7) + Filter Operator [FIL_212] (rows=525327388 width=7) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) TableScan [TS_9] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"] <-Reducer 14 [BROADCAST_EDGE] vectorized - BROADCAST [RS_206] - Group By Operator [GBY_205] (rows=1 width=12) + BROADCAST [RS_211] + Group By Operator [GBY_210] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_202] - Group By Operator [GBY_199] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_207] + Group By Operator [GBY_204] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_194] (rows=201 width=4) + Select Operator [SEL_199] (rows=201 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_192] + Please refer to the previous Select Operator [SEL_197] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_55] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_175] (rows=228127 width=375) - Conds:RS_50._col1=RS_190._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Merge Join Operator [MERGEJOIN_180] (rows=228127 width=375) + Conds:RS_50._col1=RS_195._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_190] + SHUFFLE [RS_195] PartitionCols:_col0 - Select Operator [SEL_189] (rows=1861800 width=375) + Select Operator [SEL_194] (rows=1861800 width=375) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_188] (rows=1861800 width=375) + Filter Operator [FIL_193] (rows=1861800 width=375) predicate:cd_demo_sk is not null TableScan [TS_6] (rows=1861800 width=375) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status","cd_purchase_estimate","cd_credit_rating","cd_dep_count","cd_dep_employed_count","cd_dep_college_count"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_50] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_174] (rows=224946 width=4) - Conds:RS_184._col2=RS_187._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_179] (rows=224946 width=4) + Conds:RS_189._col2=RS_192._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_184] + SHUFFLE [RS_189] PartitionCols:_col2 - Select Operator [SEL_183] (rows=77201384 width=11) + Select Operator [SEL_188] (rows=77201384 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_182] (rows=77201384 width=11) + Filter Operator [FIL_187] (rows=77201384 width=11) predicate:(c_current_cdemo_sk is not null and c_current_addr_sk is not null and c_customer_sk is not null) TableScan [TS_0] (rows=80000000 width=11) default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_187] + SHUFFLE [RS_192] PartitionCols:_col0 - Select Operator [SEL_186] (rows=116550 width=102) + Select Operator [SEL_191] (rows=116550 width=102) Output:["_col0"] - Filter Operator [FIL_185] (rows=116550 width=102) + Filter Operator [FIL_190] (rows=116550 width=102) predicate:((ca_county) IN ('Walker County', 'Richland County', 'Gaines County', 'Douglas County', 'Dona Ana County') and ca_address_sk is not null) TableScan [TS_3] (rows=40000000 width=102) default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county"] diff --git ql/src/test/results/clientpositive/perf/tez/query11.q.out ql/src/test/results/clientpositive/perf/tez/query11.q.out index 96bdd7b504..82e9b9f3e8 100644 --- ql/src/test/results/clientpositive/perf/tez/query11.q.out +++ ql/src/test/results/clientpositive/perf/tez/query11.q.out @@ -189,241 +189,243 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_354] - Limit [LIM_353] (rows=100 width=85) + File Output Operator [FS_355] + Limit [LIM_354] (rows=100 width=85) Number of rows:100 - Select Operator [SEL_352] (rows=19066162 width=85) + Select Operator [SEL_353] (rows=19066162 width=85) Output:["_col0"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_93] Select Operator [SEL_92] (rows=19066162 width=85) Output:["_col0"] - Filter Operator [FIL_91] (rows=19066162 width=537) - predicate:CASE WHEN (_col3 is not null) THEN (CASE WHEN (_col6) THEN (((_col1 / _col5) > (_col9 / _col3))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_287] (rows=38132324 width=537) - Conds:RS_88._col2=RS_351._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col8","_col9"] - <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_351] - PartitionCols:_col0 - Select Operator [SEL_350] (rows=80000000 width=297) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_349] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_79] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_78] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_284] (rows=525327388 width=764) - Conds:RS_74._col1=RS_317._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_317] - PartitionCols:_col0 - Select Operator [SEL_316] (rows=80000000 width=656) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_315] (rows=80000000 width=656) - predicate:(c_customer_sk is not null and c_customer_id is not null) - TableScan [TS_68] (rows=80000000 width=656) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_74] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_283] (rows=525327388 width=115) - Conds:RS_348._col0=RS_294._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_294] - PartitionCols:_col0 - Select Operator [SEL_291] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_288] (rows=652 width=8) - predicate:((d_year = 2002) and d_date_sk is not null) - TableScan [TS_65] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Select Operator [SEL_347] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_346] (rows=525327388 width=221) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_72_date_dim_d_date_sk_min) AND DynamicValue(RS_72_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_72_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_62] (rows=575995635 width=221) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] - <-Reducer 22 [BROADCAST_EDGE] vectorized - BROADCAST [RS_345] - Group By Operator [GBY_344] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_306] - Group By Operator [GBY_302] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_295] (rows=652 width=4) + Top N Key Operator [TNK_158] (rows=19066162 width=537) + keys:_col8,top n:100 + Filter Operator [FIL_91] (rows=19066162 width=537) + predicate:CASE WHEN (_col3 is not null) THEN (CASE WHEN (_col6) THEN (((_col1 / _col5) > (_col9 / _col3))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_288] (rows=38132324 width=537) + Conds:RS_88._col2=RS_352._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col8","_col9"] + <-Reducer 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_352] + PartitionCols:_col0 + Select Operator [SEL_351] (rows=80000000 width=297) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_350] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_79] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_78] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_285] (rows=525327388 width=764) + Conds:RS_74._col1=RS_318._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_318] + PartitionCols:_col0 + Select Operator [SEL_317] (rows=80000000 width=656) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_316] (rows=80000000 width=656) + predicate:(c_customer_sk is not null and c_customer_id is not null) + TableScan [TS_68] (rows=80000000 width=656) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_74] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_284] (rows=525327388 width=115) + Conds:RS_349._col0=RS_295._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_295] + PartitionCols:_col0 + Select Operator [SEL_292] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_289] (rows=652 width=8) + predicate:((d_year = 2002) and d_date_sk is not null) + TableScan [TS_65] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] + PartitionCols:_col0 + Select Operator [SEL_348] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_347] (rows=525327388 width=221) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_72_date_dim_d_date_sk_min) AND DynamicValue(RS_72_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_72_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_62] (rows=575995635 width=221) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] + <-Reducer 22 [BROADCAST_EDGE] vectorized + BROADCAST [RS_346] + Group By Operator [GBY_345] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_307] + Group By Operator [GBY_303] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_296] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_292] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_287] (rows=31888273 width=440) + Conds:RS_85._col2=RS_344._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Reducer 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_344] + PartitionCols:_col0 + Select Operator [SEL_343] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_342] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_341] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_340] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_58] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_57] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_283] (rows=143930993 width=764) + Conds:RS_53._col1=RS_321._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_321] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_317] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_53] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_282] (rows=143930993 width=115) + Conds:RS_339._col0=RS_301._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_301] + PartitionCols:_col0 + Select Operator [SEL_294] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_291] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_65] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_339] + PartitionCols:_col0 + Select Operator [SEL_338] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_337] (rows=143930993 width=231) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_41] (rows=144002668 width=231) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] + <-Reducer 25 [BROADCAST_EDGE] vectorized + BROADCAST [RS_336] + Group By Operator [GBY_335] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_310] + Group By Operator [GBY_306] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_302] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_294] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_286] (rows=31888273 width=324) + Conds:RS_324._col0=RS_334._col0(Inner),Output:["_col1","_col2","_col3"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_334] + PartitionCols:_col0 + Select Operator [SEL_333] (rows=26666666 width=212) + Output:["_col0","_col1"] + Filter Operator [FIL_332] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_331] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_330] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_36] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_281] (rows=525327388 width=764) + Conds:RS_32._col1=RS_320._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_320] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_317] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=115) + Conds:RS_329._col0=RS_299._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_299] + PartitionCols:_col0 + Select Operator [SEL_293] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_291] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_286] (rows=31888273 width=440) - Conds:RS_85._col2=RS_343._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_343] - PartitionCols:_col0 - Select Operator [SEL_342] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_341] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_340] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_339] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_58] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_57] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_282] (rows=143930993 width=764) - Conds:RS_53._col1=RS_320._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_320] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_316] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_53] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_281] (rows=143930993 width=115) - Conds:RS_338._col0=RS_300._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_300] - PartitionCols:_col0 - Select Operator [SEL_293] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_290] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_65] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_338] - PartitionCols:_col0 - Select Operator [SEL_337] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_336] (rows=143930993 width=231) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_41] (rows=144002668 width=231) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] - <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_335] - Group By Operator [GBY_334] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_309] - Group By Operator [GBY_305] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_301] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_293] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_285] (rows=31888273 width=324) - Conds:RS_323._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_333] - PartitionCols:_col0 - Select Operator [SEL_332] (rows=26666666 width=212) - Output:["_col0","_col1"] - Filter Operator [FIL_331] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_330] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_329] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_36] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=764) - Conds:RS_32._col1=RS_319._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_316] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_279] (rows=525327388 width=115) - Conds:RS_328._col0=RS_298._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_298] - PartitionCols:_col0 - Select Operator [SEL_292] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_289] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_65] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_328] - PartitionCols:_col0 - Select Operator [SEL_327] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_326] (rows=525327388 width=221) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=575995635 width=221) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_325] - Group By Operator [GBY_324] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_308] - Group By Operator [GBY_304] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_299] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_292] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Select Operator [SEL_322] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_321] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_16] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=764) - Conds:RS_12._col1=RS_318._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_316] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_277] (rows=143930993 width=115) - Conds:RS_314._col0=RS_296._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_296] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_291] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_314] - PartitionCols:_col0 - Select Operator [SEL_313] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_312] (rows=143930993 width=231) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=231) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] - <-Reducer 23 [BROADCAST_EDGE] vectorized - BROADCAST [RS_311] - Group By Operator [GBY_310] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_307] - Group By Operator [GBY_303] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_297] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_291] + Filter Operator [FIL_290] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_65] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_329] + PartitionCols:_col0 + Select Operator [SEL_328] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_327] (rows=525327388 width=221) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=575995635 width=221) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_list_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_326] + Group By Operator [GBY_325] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_309] + Group By Operator [GBY_305] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_300] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_293] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_324] + PartitionCols:_col0 + Select Operator [SEL_323] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_322] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_16] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_279] (rows=143930993 width=764) + Conds:RS_12._col1=RS_319._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_319] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_317] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=115) + Conds:RS_315._col0=RS_297._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_297] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_292] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_315] + PartitionCols:_col0 + Select Operator [SEL_314] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_313] (rows=143930993 width=231) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=231) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_list_price"] + <-Reducer 23 [BROADCAST_EDGE] vectorized + BROADCAST [RS_312] + Group By Operator [GBY_311] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_308] + Group By Operator [GBY_304] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_298] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_292] diff --git ql/src/test/results/clientpositive/perf/tez/query12.q.out ql/src/test/results/clientpositive/perf/tez/query12.q.out index 4183059b2d..3e2c464421 100644 --- ql/src/test/results/clientpositive/perf/tez/query12.q.out +++ ql/src/test/results/clientpositive/perf/tez/query12.q.out @@ -86,72 +86,74 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_81] - Limit [LIM_80] (rows=100 width=802) + File Output Operator [FS_83] + Limit [LIM_82] (rows=100 width=802) Number of rows:100 - Select Operator [SEL_79] (rows=138600 width=801) + Select Operator [SEL_81] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_78] - Select Operator [SEL_77] (rows=138600 width=801) + SHUFFLE [RS_80] + Select Operator [SEL_79] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_76] (rows=138600 width=690) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] - Select Operator [SEL_75] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_74] - PartitionCols:_col1 - Group By Operator [GBY_73] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_16] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_58] (rows=43190061 width=689) - Conds:RS_12._col1=RS_72._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_72] - PartitionCols:_col0 - Select Operator [SEL_71] (rows=138600 width=581) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_70] (rows=138600 width=581) - predicate:((i_category) IN ('Jewelry', 'Sports', 'Books') and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=581) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_57] (rows=143966864 width=115) - Conds:RS_69._col0=RS_61._col0(Inner),Output:["_col1","_col2"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_61] - PartitionCols:_col0 - Select Operator [SEL_60] (rows=8116 width=4) - Output:["_col0"] - Filter Operator [FIL_59] (rows=8116 width=98) - predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_67] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_66] - Group By Operator [GBY_65] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_64] - Group By Operator [GBY_63] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_62] (rows=8116 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_60] + Top N Key Operator [TNK_78] (rows=138600 width=690) + keys:_col0, _col1, _col2, _col3, ((_col5 * 100) / sum_window_0),top n:100 + PTF Operator [PTF_77] (rows=138600 width=690) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] + Select Operator [SEL_76] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_75] + PartitionCols:_col1 + Group By Operator [GBY_74] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_16] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_59] (rows=43190061 width=689) + Conds:RS_12._col1=RS_73._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_73] + PartitionCols:_col0 + Select Operator [SEL_72] (rows=138600 width=581) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_71] (rows=138600 width=581) + predicate:((i_category) IN ('Jewelry', 'Sports', 'Books') and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=581) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_58] (rows=143966864 width=115) + Conds:RS_70._col0=RS_62._col0(Inner),Output:["_col1","_col2"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_62] + PartitionCols:_col0 + Select Operator [SEL_61] (rows=8116 width=4) + Output:["_col0"] + Filter Operator [FIL_60] (rows=8116 width=98) + predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_70] + PartitionCols:_col0 + Select Operator [SEL_69] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_68] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_67] + Group By Operator [GBY_66] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_65] + Group By Operator [GBY_64] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_63] (rows=8116 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_61] diff --git ql/src/test/results/clientpositive/perf/tez/query14.q.out ql/src/test/results/clientpositive/perf/tez/query14.q.out index 069fad2b4a..00bc4cb026 100644 --- ql/src/test/results/clientpositive/perf/tez/query14.q.out +++ ql/src/test/results/clientpositive/perf/tez/query14.q.out @@ -1,6 +1,6 @@ -Warning: Shuffle Join MERGEJOIN[1173][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product -Warning: Shuffle Join MERGEJOIN[1180][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product -Warning: Shuffle Join MERGEJOIN[1187][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product +Warning: Shuffle Join MERGEJOIN[1175][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 6' is a cross product +Warning: Shuffle Join MERGEJOIN[1182][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[1189][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 22' is a cross product PREHOOK: query: explain with cross_items as (select i_item_sk ss_item_sk @@ -296,36 +296,36 @@ Stage-0 limit:100 Stage-1 Reducer 9 vectorized - File Output Operator [FS_1346] - Limit [LIM_1345] (rows=100 width=223) + File Output Operator [FS_1348] + Limit [LIM_1347] (rows=100 width=223) Number of rows:100 - Select Operator [SEL_1344] (rows=304320 width=223) + Select Operator [SEL_1346] (rows=304320 width=223) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1343] - Select Operator [SEL_1342] (rows=304320 width=223) + SHUFFLE [RS_1345] + Select Operator [SEL_1344] (rows=304320 width=223) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_1341] (rows=304320 width=231) + Group By Operator [GBY_1343] (rows=304320 width=231) Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 7 [SIMPLE_EDGE] <-Reducer 16 [CONTAINS] - Reduce Output Operator [RS_1186] + Reduce Output Operator [RS_1188] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_1185] (rows=304320 width=231) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L - Top N Key Operator [TNK_1184] (rows=121728 width=221) - keys:_col0, _col1, _col2, _col3, 0L,top n:100 - Select Operator [SEL_1182] (rows=40576 width=223) + Top N Key Operator [TNK_1187] (rows=304320 width=231) + keys:_col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_1186] (rows=304320 width=231) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L + Select Operator [SEL_1184] (rows=40576 width=223) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_1181] (rows=40576 width=244) + Filter Operator [FIL_1183] (rows=40576 width=244) predicate:(_col3 > _col5) - Merge Join Operator [MERGEJOIN_1180] (rows=121728 width=244) + Merge Join Operator [MERGEJOIN_1182] (rows=121728 width=244) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 15 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1358] - Filter Operator [FIL_1357] (rows=121728 width=132) + PARTITION_ONLY_SHUFFLE [RS_1360] + Filter Operator [FIL_1359] (rows=121728 width=132) predicate:_col3 is not null - Group By Operator [GBY_1356] (rows=121728 width=132) + Group By Operator [GBY_1358] (rows=121728 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_244] @@ -334,378 +334,378 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 Select Operator [SEL_241] (rows=286549727 width=127) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_1168] (rows=286549727 width=127) + Merge Join Operator [MERGEJOIN_1170] (rows=286549727 width=127) Conds:RS_238._col1=RS_239._col0(Left Semi),Output:["_col2","_col3","_col6","_col7","_col8"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_238] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1144] (rows=286549727 width=131) - Conds:RS_233._col1=RS_1326._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_1146] (rows=286549727 width=131) + Conds:RS_233._col1=RS_1328._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1326] + SHUFFLE [RS_1328] PartitionCols:_col0 - Select Operator [SEL_1317] (rows=462000 width=15) + Select Operator [SEL_1319] (rows=462000 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1308] (rows=462000 width=15) + Filter Operator [FIL_1310] (rows=462000 width=15) predicate:i_item_sk is not null TableScan [TS_6] (rows=462000 width=15) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_233] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1143] (rows=286549727 width=119) - Conds:RS_1351._col0=RS_1288._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_1145] (rows=286549727 width=119) + Conds:RS_1353._col0=RS_1290._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 10 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1288] + PARTITION_ONLY_SHUFFLE [RS_1290] PartitionCols:_col0 - Select Operator [SEL_1285] (rows=50 width=4) + Select Operator [SEL_1287] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_1284] (rows=50 width=12) + Filter Operator [FIL_1286] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 11) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 79 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1351] + SHUFFLE [RS_1353] PartitionCols:_col0 - Select Operator [SEL_1350] (rows=286549727 width=123) + Select Operator [SEL_1352] (rows=286549727 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1349] (rows=286549727 width=123) + Filter Operator [FIL_1351] (rows=286549727 width=123) predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_231_date_dim_d_date_sk_min) AND DynamicValue(RS_231_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_231_date_dim_d_date_sk_bloom_filter))) TableScan [TS_146] (rows=287989836 width=123) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_quantity","cs_list_price"] <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1348] - Group By Operator [GBY_1347] (rows=1 width=12) + BROADCAST [RS_1350] + Group By Operator [GBY_1349] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1296] - Group By Operator [GBY_1293] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1298] + Group By Operator [GBY_1295] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1289] (rows=50 width=4) + Select Operator [SEL_1291] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1285] + Please refer to the previous Select Operator [SEL_1287] <-Reducer 33 [SIMPLE_EDGE] SHUFFLE [RS_239] PartitionCols:_col0 Group By Operator [GBY_237] (rows=364 width=4) Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_1151] (rows=729 width=4) - Conds:RS_1327._col1, _col2, _col3=RS_1355._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_1153] (rows=729 width=4) + Conds:RS_1329._col1, _col2, _col3=RS_1357._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1327] + SHUFFLE [RS_1329] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_1318] (rows=458612 width=15) + Select Operator [SEL_1320] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1309] (rows=458612 width=15) + Filter Operator [FIL_1311] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 32 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1355] + SHUFFLE [RS_1357] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_1354] (rows=1 width=12) + Select Operator [SEL_1356] (rows=1 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1353] (rows=1 width=20) + Filter Operator [FIL_1355] (rows=1 width=20) predicate:(_col3 = 3L) - Group By Operator [GBY_1352] (rows=120960 width=20) + Group By Operator [GBY_1354] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 31 [SIMPLE_EDGE] <-Reducer 30 [CONTAINS] vectorized - Reduce Output Operator [RS_1409] + Reduce Output Operator [RS_1411] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1408] (rows=120960 width=20) + Group By Operator [GBY_1410] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1407] (rows=120960 width=20) + Group By Operator [GBY_1409] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_175] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_28] (rows=3144960 width=19) Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, _col5, _col6 - Merge Join Operator [MERGEJOIN_1134] (rows=546042657 width=11) - Conds:RS_24._col1=RS_1323._col0(Inner),Output:["_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_1136] (rows=546042657 width=11) + Conds:RS_24._col1=RS_1325._col0(Inner),Output:["_col4","_col5","_col6"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1323] + SHUFFLE [RS_1325] PartitionCols:_col0 - Select Operator [SEL_1314] (rows=458612 width=15) + Select Operator [SEL_1316] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1305] (rows=458612 width=15) + Filter Operator [FIL_1307] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 47 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1133] (rows=550076554 width=4) - Conds:RS_1403._col0=RS_1381._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_1135] (rows=550076554 width=4) + Conds:RS_1405._col0=RS_1383._col0(Inner),Output:["_col1"] <-Map 48 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1381] + SHUFFLE [RS_1383] PartitionCols:_col0 - Select Operator [SEL_1380] (rows=1957 width=4) + Select Operator [SEL_1382] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_1379] (rows=1957 width=8) + Filter Operator [FIL_1381] (rows=1957 width=8) predicate:(d_year BETWEEN 1999 AND 2001 and d_date_sk is not null) TableScan [TS_15] (rows=73049 width=8) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 46 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1403] + SHUFFLE [RS_1405] PartitionCols:_col0 - Select Operator [SEL_1402] (rows=550076554 width=7) + Select Operator [SEL_1404] (rows=550076554 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_1401] (rows=550076554 width=7) + Filter Operator [FIL_1403] (rows=550076554 width=7) predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_22_d1_d_date_sk_min) AND DynamicValue(RS_22_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_22_d1_d_date_sk_bloom_filter))) TableScan [TS_12] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk"] <-Reducer 49 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1400] - Group By Operator [GBY_1399] (rows=1 width=12) + BROADCAST [RS_1402] + Group By Operator [GBY_1401] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1395] - Group By Operator [GBY_1391] (rows=1 width=12) + SHUFFLE [RS_1397] + Group By Operator [GBY_1393] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1382] (rows=1957 width=4) + Select Operator [SEL_1384] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Reducer 40 [CONTAINS] vectorized - Reduce Output Operator [RS_1423] + Reduce Output Operator [RS_1425] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1422] (rows=120960 width=20) + Group By Operator [GBY_1424] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1421] (rows=120960 width=20) + Group By Operator [GBY_1423] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 38 [SIMPLE_EDGE] SHUFFLE [RS_195] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_48] (rows=1693440 width=19) Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, _col5, _col6 - Merge Join Operator [MERGEJOIN_1136] (rows=284448361 width=11) - Conds:RS_44._col1=RS_1324._col0(Inner),Output:["_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_1138] (rows=284448361 width=11) + Conds:RS_44._col1=RS_1326._col0(Inner),Output:["_col4","_col5","_col6"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1324] + SHUFFLE [RS_1326] PartitionCols:_col0 - Select Operator [SEL_1315] (rows=458612 width=15) + Select Operator [SEL_1317] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1306] (rows=458612 width=15) + Filter Operator [FIL_1308] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 50 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1135] (rows=286549727 width=4) - Conds:RS_1417._col0=RS_1383._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_1137] (rows=286549727 width=4) + Conds:RS_1419._col0=RS_1385._col0(Inner),Output:["_col1"] <-Map 48 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1383] + SHUFFLE [RS_1385] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Map 64 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1417] + SHUFFLE [RS_1419] PartitionCols:_col0 - Select Operator [SEL_1416] (rows=286549727 width=7) + Select Operator [SEL_1418] (rows=286549727 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_1415] (rows=286549727 width=7) + Filter Operator [FIL_1417] (rows=286549727 width=7) predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_42_d2_d_date_sk_min) AND DynamicValue(RS_42_d2_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_42_d2_d_date_sk_bloom_filter))) TableScan [TS_32] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk"] <-Reducer 51 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1414] - Group By Operator [GBY_1413] (rows=1 width=12) + BROADCAST [RS_1416] + Group By Operator [GBY_1415] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1396] - Group By Operator [GBY_1392] (rows=1 width=12) + SHUFFLE [RS_1398] + Group By Operator [GBY_1394] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1384] (rows=1957 width=4) + Select Operator [SEL_1386] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Reducer 44 [CONTAINS] vectorized - Reduce Output Operator [RS_1437] + Reduce Output Operator [RS_1439] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1436] (rows=120960 width=20) + Group By Operator [GBY_1438] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1435] (rows=120960 width=20) + Group By Operator [GBY_1437] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 42 [SIMPLE_EDGE] SHUFFLE [RS_216] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_69] (rows=846720 width=19) Output:["_col0","_col1","_col2","_col3"],aggregations:["count()"],keys:_col4, _col5, _col6 - Merge Join Operator [MERGEJOIN_1138] (rows=142911107 width=11) - Conds:RS_65._col1=RS_1325._col0(Inner),Output:["_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_1140] (rows=142911107 width=11) + Conds:RS_65._col1=RS_1327._col0(Inner),Output:["_col4","_col5","_col6"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1325] + SHUFFLE [RS_1327] PartitionCols:_col0 - Select Operator [SEL_1316] (rows=458612 width=15) + Select Operator [SEL_1318] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1307] (rows=458612 width=15) + Filter Operator [FIL_1309] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 52 [SIMPLE_EDGE] SHUFFLE [RS_65] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1137] (rows=143966864 width=4) - Conds:RS_1431._col0=RS_1385._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_1139] (rows=143966864 width=4) + Conds:RS_1433._col0=RS_1387._col0(Inner),Output:["_col1"] <-Map 48 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1385] + SHUFFLE [RS_1387] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Map 65 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1431] + SHUFFLE [RS_1433] PartitionCols:_col0 - Select Operator [SEL_1430] (rows=143966864 width=7) + Select Operator [SEL_1432] (rows=143966864 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_1429] (rows=143966864 width=7) + Filter Operator [FIL_1431] (rows=143966864 width=7) predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_63_d3_d_date_sk_min) AND DynamicValue(RS_63_d3_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_63_d3_d_date_sk_bloom_filter))) TableScan [TS_53] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk"] <-Reducer 53 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1428] - Group By Operator [GBY_1427] (rows=1 width=12) + BROADCAST [RS_1430] + Group By Operator [GBY_1429] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1397] - Group By Operator [GBY_1393] (rows=1 width=12) + SHUFFLE [RS_1399] + Group By Operator [GBY_1395] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1386] (rows=1957 width=4) + Select Operator [SEL_1388] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Reducer 60 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1362] - Select Operator [SEL_1361] (rows=1 width=112) + PARTITION_ONLY_SHUFFLE [RS_1364] + Select Operator [SEL_1363] (rows=1 width=112) Output:["_col0"] - Filter Operator [FIL_1360] (rows=1 width=120) + Filter Operator [FIL_1362] (rows=1 width=120) predicate:(_col0 is not null and _col1 is not null) - Group By Operator [GBY_1359] (rows=1 width=120) + Group By Operator [GBY_1361] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"] <-Union 59 [CUSTOM_SIMPLE_EDGE] <-Reducer 58 [CONTAINS] - Reduce Output Operator [RS_1241] - Group By Operator [GBY_1240] (rows=1 width=120) + Reduce Output Operator [RS_1243] + Group By Operator [GBY_1242] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1239] (rows=980593145 width=112) + Select Operator [SEL_1241] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1237] (rows=550076554 width=110) + Select Operator [SEL_1239] (rows=550076554 width=110) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1236] (rows=550076554 width=110) - Conds:RS_1446._col0=RS_1389._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1238] (rows=550076554 width=110) + Conds:RS_1448._col0=RS_1391._col0(Inner),Output:["_col1","_col2"] <-Map 48 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1389] + SHUFFLE [RS_1391] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Map 66 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1446] + SHUFFLE [RS_1448] PartitionCols:_col0 - Select Operator [SEL_1444] (rows=550076554 width=114) + Select Operator [SEL_1446] (rows=550076554 width=114) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1443] (rows=550076554 width=114) + Filter Operator [FIL_1445] (rows=550076554 width=114) predicate:(ss_sold_date_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_109_date_dim_d_date_sk_min) AND DynamicValue(RS_109_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_109_date_dim_d_date_sk_bloom_filter))) TableScan [TS_102] (rows=575995635 width=114) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_quantity","ss_list_price"] <-Reducer 57 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1442] - Group By Operator [GBY_1441] (rows=1 width=12) + BROADCAST [RS_1444] + Group By Operator [GBY_1443] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 48 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_1398] - Group By Operator [GBY_1394] (rows=1 width=12) + SHUFFLE [RS_1400] + Group By Operator [GBY_1396] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1388] (rows=1957 width=4) + Select Operator [SEL_1390] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Reducer 69 [CONTAINS] - Reduce Output Operator [RS_1259] - Group By Operator [GBY_1258] (rows=1 width=120) + Reduce Output Operator [RS_1261] + Group By Operator [GBY_1260] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1257] (rows=980593145 width=112) + Select Operator [SEL_1259] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1255] (rows=286549727 width=115) + Select Operator [SEL_1257] (rows=286549727 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1254] (rows=286549727 width=115) - Conds:RS_1461._col0=RS_1452._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1256] (rows=286549727 width=115) + Conds:RS_1463._col0=RS_1454._col0(Inner),Output:["_col1","_col2"] <-Map 71 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1452] + PARTITION_ONLY_SHUFFLE [RS_1454] PartitionCols:_col0 - Select Operator [SEL_1449] (rows=1957 width=4) + Select Operator [SEL_1451] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_1448] (rows=1957 width=8) + Filter Operator [FIL_1450] (rows=1957 width=8) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) TableScan [TS_115] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 67 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1461] + SHUFFLE [RS_1463] PartitionCols:_col0 - Select Operator [SEL_1459] (rows=286549727 width=119) + Select Operator [SEL_1461] (rows=286549727 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1458] (rows=286549727 width=119) + Filter Operator [FIL_1460] (rows=286549727 width=119) predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_119_date_dim_d_date_sk_min) AND DynamicValue(RS_119_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_119_date_dim_d_date_sk_bloom_filter))) TableScan [TS_112] (rows=287989836 width=119) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_quantity","cs_list_price"] <-Reducer 72 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1457] - Group By Operator [GBY_1456] (rows=1 width=12) + BROADCAST [RS_1459] + Group By Operator [GBY_1458] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 71 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1455] - Group By Operator [GBY_1454] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1457] + Group By Operator [GBY_1456] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1451] (rows=1957 width=4) + Select Operator [SEL_1453] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1449] + Please refer to the previous Select Operator [SEL_1451] <-Reducer 75 [CONTAINS] - Reduce Output Operator [RS_1277] - Group By Operator [GBY_1276] (rows=1 width=120) + Reduce Output Operator [RS_1279] + Group By Operator [GBY_1278] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1275] (rows=980593145 width=112) + Select Operator [SEL_1277] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1273] (rows=143966864 width=115) + Select Operator [SEL_1275] (rows=143966864 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1272] (rows=143966864 width=115) - Conds:RS_1476._col0=RS_1467._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1274] (rows=143966864 width=115) + Conds:RS_1478._col0=RS_1469._col0(Inner),Output:["_col1","_col2"] <-Map 77 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1467] + PARTITION_ONLY_SHUFFLE [RS_1469] PartitionCols:_col0 - Select Operator [SEL_1464] (rows=1957 width=4) + Select Operator [SEL_1466] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_1463] (rows=1957 width=8) + Filter Operator [FIL_1465] (rows=1957 width=8) predicate:(d_year BETWEEN 1998 AND 2000 and d_date_sk is not null) TableScan [TS_126] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 73 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1476] + SHUFFLE [RS_1478] PartitionCols:_col0 - Select Operator [SEL_1474] (rows=143966864 width=119) + Select Operator [SEL_1476] (rows=143966864 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1473] (rows=143966864 width=119) + Filter Operator [FIL_1475] (rows=143966864 width=119) predicate:(ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_130_date_dim_d_date_sk_min) AND DynamicValue(RS_130_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_130_date_dim_d_date_sk_bloom_filter))) TableScan [TS_123] (rows=144002668 width=119) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_quantity","ws_list_price"] <-Reducer 78 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1472] - Group By Operator [GBY_1471] (rows=1 width=12) + BROADCAST [RS_1474] + Group By Operator [GBY_1473] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 77 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1470] - Group By Operator [GBY_1469] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1472] + Group By Operator [GBY_1471] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1466] (rows=1957 width=4) + Select Operator [SEL_1468] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1464] + Please refer to the previous Select Operator [SEL_1466] <-Reducer 22 [CONTAINS] - Reduce Output Operator [RS_1193] + Reduce Output Operator [RS_1195] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_1192] (rows=304320 width=231) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L - Top N Key Operator [TNK_1191] (rows=121728 width=221) - keys:_col0, _col1, _col2, _col3, 0L,top n:100 - Select Operator [SEL_1189] (rows=40576 width=219) + Top N Key Operator [TNK_1194] (rows=304320 width=231) + keys:_col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_1193] (rows=304320 width=231) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L + Select Operator [SEL_1191] (rows=40576 width=219) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_1188] (rows=40576 width=244) + Filter Operator [FIL_1190] (rows=40576 width=244) predicate:(_col3 > _col5) - Merge Join Operator [MERGEJOIN_1187] (rows=121728 width=244) + Merge Join Operator [MERGEJOIN_1189] (rows=121728 width=244) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1374] - Filter Operator [FIL_1373] (rows=121728 width=132) + PARTITION_ONLY_SHUFFLE [RS_1376] + Filter Operator [FIL_1375] (rows=121728 width=132) predicate:_col3 is not null - Group By Operator [GBY_1372] (rows=121728 width=132) + Group By Operator [GBY_1374] (rows=121728 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_391] @@ -714,189 +714,189 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 Select Operator [SEL_388] (rows=143966864 width=127) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_1169] (rows=143966864 width=127) + Merge Join Operator [MERGEJOIN_1171] (rows=143966864 width=127) Conds:RS_385._col1=RS_386._col0(Left Semi),Output:["_col2","_col3","_col6","_col7","_col8"] <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_385] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1156] (rows=143966864 width=131) - Conds:RS_380._col1=RS_1328._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_1158] (rows=143966864 width=131) + Conds:RS_380._col1=RS_1330._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1328] + SHUFFLE [RS_1330] PartitionCols:_col0 - Select Operator [SEL_1319] (rows=462000 width=15) + Select Operator [SEL_1321] (rows=462000 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1310] (rows=462000 width=15) + Filter Operator [FIL_1312] (rows=462000 width=15) predicate:i_item_sk is not null Please refer to the previous TableScan [TS_6] <-Reducer 18 [SIMPLE_EDGE] SHUFFLE [RS_380] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1155] (rows=143966864 width=119) - Conds:RS_1367._col0=RS_1290._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_1157] (rows=143966864 width=119) + Conds:RS_1369._col0=RS_1292._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 10 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1290] + PARTITION_ONLY_SHUFFLE [RS_1292] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1285] + Please refer to the previous Select Operator [SEL_1287] <-Map 80 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1367] + SHUFFLE [RS_1369] PartitionCols:_col0 - Select Operator [SEL_1366] (rows=143966864 width=123) + Select Operator [SEL_1368] (rows=143966864 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1365] (rows=143966864 width=123) + Filter Operator [FIL_1367] (rows=143966864 width=123) predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_378_date_dim_d_date_sk_min) AND DynamicValue(RS_378_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_378_date_dim_d_date_sk_bloom_filter))) TableScan [TS_293] (rows=144002668 width=123) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_quantity","ws_list_price"] <-Reducer 23 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1364] - Group By Operator [GBY_1363] (rows=1 width=12) + BROADCAST [RS_1366] + Group By Operator [GBY_1365] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1297] - Group By Operator [GBY_1294] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1299] + Group By Operator [GBY_1296] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1291] (rows=50 width=4) + Select Operator [SEL_1293] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1285] + Please refer to the previous Select Operator [SEL_1287] <-Reducer 37 [SIMPLE_EDGE] SHUFFLE [RS_386] PartitionCols:_col0 Group By Operator [GBY_384] (rows=364 width=4) Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_1163] (rows=729 width=4) - Conds:RS_1329._col1, _col2, _col3=RS_1371._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_1165] (rows=729 width=4) + Conds:RS_1331._col1, _col2, _col3=RS_1373._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1329] + SHUFFLE [RS_1331] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_1320] (rows=458612 width=15) + Select Operator [SEL_1322] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1311] (rows=458612 width=15) + Filter Operator [FIL_1313] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 36 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1371] + SHUFFLE [RS_1373] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_1370] (rows=1 width=12) + Select Operator [SEL_1372] (rows=1 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1369] (rows=1 width=20) + Filter Operator [FIL_1371] (rows=1 width=20) predicate:(_col3 = 3L) - Group By Operator [GBY_1368] (rows=120960 width=20) + Group By Operator [GBY_1370] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 35 [SIMPLE_EDGE] <-Reducer 34 [CONTAINS] vectorized - Reduce Output Operator [RS_1412] + Reduce Output Operator [RS_1414] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1411] (rows=120960 width=20) + Group By Operator [GBY_1413] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1410] (rows=120960 width=20) + Group By Operator [GBY_1412] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_322] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_28] <-Reducer 41 [CONTAINS] vectorized - Reduce Output Operator [RS_1426] + Reduce Output Operator [RS_1428] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1425] (rows=120960 width=20) + Group By Operator [GBY_1427] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1424] (rows=120960 width=20) + Group By Operator [GBY_1426] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 38 [SIMPLE_EDGE] SHUFFLE [RS_342] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_48] <-Reducer 45 [CONTAINS] vectorized - Reduce Output Operator [RS_1440] + Reduce Output Operator [RS_1442] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1439] (rows=120960 width=20) + Group By Operator [GBY_1441] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1438] (rows=120960 width=20) + Group By Operator [GBY_1440] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 42 [SIMPLE_EDGE] SHUFFLE [RS_363] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_69] <-Reducer 63 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1378] - Select Operator [SEL_1377] (rows=1 width=112) + PARTITION_ONLY_SHUFFLE [RS_1380] + Select Operator [SEL_1379] (rows=1 width=112) Output:["_col0"] - Filter Operator [FIL_1376] (rows=1 width=120) + Filter Operator [FIL_1378] (rows=1 width=120) predicate:(_col0 is not null and _col1 is not null) - Group By Operator [GBY_1375] (rows=1 width=120) + Group By Operator [GBY_1377] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"] <-Union 62 [CUSTOM_SIMPLE_EDGE] <-Reducer 61 [CONTAINS] - Reduce Output Operator [RS_1247] - Group By Operator [GBY_1246] (rows=1 width=120) + Reduce Output Operator [RS_1249] + Group By Operator [GBY_1248] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1245] (rows=980593145 width=112) + Select Operator [SEL_1247] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1243] (rows=550076554 width=110) + Select Operator [SEL_1245] (rows=550076554 width=110) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1242] (rows=550076554 width=110) - Conds:RS_1447._col0=RS_1390._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1244] (rows=550076554 width=110) + Conds:RS_1449._col0=RS_1392._col0(Inner),Output:["_col1","_col2"] <-Map 48 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1390] + SHUFFLE [RS_1392] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Map 66 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1447] + SHUFFLE [RS_1449] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1444] + Please refer to the previous Select Operator [SEL_1446] <-Reducer 70 [CONTAINS] - Reduce Output Operator [RS_1265] - Group By Operator [GBY_1264] (rows=1 width=120) + Reduce Output Operator [RS_1267] + Group By Operator [GBY_1266] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1263] (rows=980593145 width=112) + Select Operator [SEL_1265] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1261] (rows=286549727 width=115) + Select Operator [SEL_1263] (rows=286549727 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1260] (rows=286549727 width=115) - Conds:RS_1462._col0=RS_1453._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1262] (rows=286549727 width=115) + Conds:RS_1464._col0=RS_1455._col0(Inner),Output:["_col1","_col2"] <-Map 71 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1453] + PARTITION_ONLY_SHUFFLE [RS_1455] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1449] + Please refer to the previous Select Operator [SEL_1451] <-Map 67 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1462] + SHUFFLE [RS_1464] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1459] + Please refer to the previous Select Operator [SEL_1461] <-Reducer 76 [CONTAINS] - Reduce Output Operator [RS_1283] - Group By Operator [GBY_1282] (rows=1 width=120) + Reduce Output Operator [RS_1285] + Group By Operator [GBY_1284] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1281] (rows=980593145 width=112) + Select Operator [SEL_1283] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1279] (rows=143966864 width=115) + Select Operator [SEL_1281] (rows=143966864 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1278] (rows=143966864 width=115) - Conds:RS_1477._col0=RS_1468._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1280] (rows=143966864 width=115) + Conds:RS_1479._col0=RS_1470._col0(Inner),Output:["_col1","_col2"] <-Map 77 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1468] + PARTITION_ONLY_SHUFFLE [RS_1470] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1464] + Please refer to the previous Select Operator [SEL_1466] <-Map 73 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1477] + SHUFFLE [RS_1479] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1474] + Please refer to the previous Select Operator [SEL_1476] <-Reducer 6 [CONTAINS] - Reduce Output Operator [RS_1179] + Reduce Output Operator [RS_1181] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_1178] (rows=304320 width=231) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L - Top N Key Operator [TNK_1177] (rows=121728 width=221) - keys:_col0, _col1, _col2, _col3, 0L,top n:100 - Select Operator [SEL_1175] (rows=40576 width=221) + Top N Key Operator [TNK_1180] (rows=304320 width=231) + keys:_col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_1179] (rows=304320 width=231) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3, 0L + Select Operator [SEL_1177] (rows=40576 width=221) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_1174] (rows=40576 width=244) + Filter Operator [FIL_1176] (rows=40576 width=244) predicate:(_col3 > _col5) - Merge Join Operator [MERGEJOIN_1173] (rows=121728 width=244) + Merge Join Operator [MERGEJOIN_1175] (rows=121728 width=244) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1336] - Filter Operator [FIL_1335] (rows=121728 width=132) + PARTITION_ONLY_SHUFFLE [RS_1338] + Filter Operator [FIL_1337] (rows=121728 width=132) predicate:_col3 is not null - Group By Operator [GBY_1334] (rows=121728 width=132) + Group By Operator [GBY_1336] (rows=121728 width=132) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_98] @@ -905,61 +905,61 @@ Stage-0 Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col3)","count()"],keys:_col0, _col1, _col2 Select Operator [SEL_95] (rows=550076554 width=122) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_1167] (rows=550076554 width=122) + Merge Join Operator [MERGEJOIN_1169] (rows=550076554 width=122) Conds:RS_92._col1=RS_93._col0(Left Semi),Output:["_col2","_col3","_col6","_col7","_col8"] <-Reducer 25 [SIMPLE_EDGE] SHUFFLE [RS_93] PartitionCols:_col0 Group By Operator [GBY_91] (rows=364 width=4) Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_1139] (rows=729 width=4) - Conds:RS_1322._col1, _col2, _col3=RS_1333._col0, _col1, _col2(Inner),Output:["_col0"] + Merge Join Operator [MERGEJOIN_1141] (rows=729 width=4) + Conds:RS_1324._col1, _col2, _col3=RS_1335._col0, _col1, _col2(Inner),Output:["_col0"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1322] + SHUFFLE [RS_1324] PartitionCols:_col1, _col2, _col3 - Select Operator [SEL_1313] (rows=458612 width=15) + Select Operator [SEL_1315] (rows=458612 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1304] (rows=458612 width=15) + Filter Operator [FIL_1306] (rows=458612 width=15) predicate:(i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) Please refer to the previous TableScan [TS_6] <-Reducer 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1333] + SHUFFLE [RS_1335] PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_1332] (rows=1 width=12) + Select Operator [SEL_1334] (rows=1 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_1331] (rows=1 width=20) + Filter Operator [FIL_1333] (rows=1 width=20) predicate:(_col3 = 3L) - Group By Operator [GBY_1330] (rows=120960 width=20) + Group By Operator [GBY_1332] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 28 [SIMPLE_EDGE] <-Reducer 27 [CONTAINS] vectorized - Reduce Output Operator [RS_1406] + Reduce Output Operator [RS_1408] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1405] (rows=120960 width=20) + Group By Operator [GBY_1407] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1404] (rows=120960 width=20) + Group By Operator [GBY_1406] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_28] <-Reducer 39 [CONTAINS] vectorized - Reduce Output Operator [RS_1420] + Reduce Output Operator [RS_1422] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1419] (rows=120960 width=20) + Group By Operator [GBY_1421] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1418] (rows=120960 width=20) + Group By Operator [GBY_1420] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 38 [SIMPLE_EDGE] SHUFFLE [RS_49] PartitionCols:_col0, _col1, _col2 Please refer to the previous Group By Operator [GBY_48] <-Reducer 43 [CONTAINS] vectorized - Reduce Output Operator [RS_1434] + Reduce Output Operator [RS_1436] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_1433] (rows=120960 width=20) + Group By Operator [GBY_1435] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(_col3)"],keys:_col0, _col1, _col2 - Group By Operator [GBY_1432] (rows=120960 width=20) + Group By Operator [GBY_1434] (rows=120960 width=20) Output:["_col0","_col1","_col2","_col3"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 42 [SIMPLE_EDGE] SHUFFLE [RS_70] @@ -968,106 +968,106 @@ Stage-0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_92] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1132] (rows=550076554 width=126) - Conds:RS_87._col1=RS_1321._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_1134] (rows=550076554 width=126) + Conds:RS_87._col1=RS_1323._col0(Inner),Output:["_col1","_col2","_col3","_col6","_col7","_col8"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1321] + SHUFFLE [RS_1323] PartitionCols:_col0 - Select Operator [SEL_1312] (rows=462000 width=15) + Select Operator [SEL_1314] (rows=462000 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1303] (rows=462000 width=15) + Filter Operator [FIL_1305] (rows=462000 width=15) predicate:i_item_sk is not null Please refer to the previous TableScan [TS_6] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_87] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_1131] (rows=550076554 width=114) - Conds:RS_1302._col0=RS_1286._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_1133] (rows=550076554 width=114) + Conds:RS_1304._col0=RS_1288._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 10 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1286] + PARTITION_ONLY_SHUFFLE [RS_1288] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1285] + Please refer to the previous Select Operator [SEL_1287] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1302] + SHUFFLE [RS_1304] PartitionCols:_col0 - Select Operator [SEL_1301] (rows=550076554 width=118) + Select Operator [SEL_1303] (rows=550076554 width=118) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_1300] (rows=550076554 width=118) + Filter Operator [FIL_1302] (rows=550076554 width=118) predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_85_date_dim_d_date_sk_min) AND DynamicValue(RS_85_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_85_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=118) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_quantity","ss_list_price"] <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_1299] - Group By Operator [GBY_1298] (rows=1 width=12) + BROADCAST [RS_1301] + Group By Operator [GBY_1300] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1295] - Group By Operator [GBY_1292] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_1297] + Group By Operator [GBY_1294] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_1287] (rows=50 width=4) + Select Operator [SEL_1289] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_1285] + Please refer to the previous Select Operator [SEL_1287] <-Reducer 56 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1340] - Select Operator [SEL_1339] (rows=1 width=112) + PARTITION_ONLY_SHUFFLE [RS_1342] + Select Operator [SEL_1341] (rows=1 width=112) Output:["_col0"] - Filter Operator [FIL_1338] (rows=1 width=120) + Filter Operator [FIL_1340] (rows=1 width=120) predicate:(_col0 is not null and _col1 is not null) - Group By Operator [GBY_1337] (rows=1 width=120) + Group By Operator [GBY_1339] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"] <-Union 55 [CUSTOM_SIMPLE_EDGE] <-Reducer 54 [CONTAINS] - Reduce Output Operator [RS_1235] - Group By Operator [GBY_1234] (rows=1 width=120) + Reduce Output Operator [RS_1237] + Group By Operator [GBY_1236] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1233] (rows=980593145 width=112) + Select Operator [SEL_1235] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1231] (rows=550076554 width=110) + Select Operator [SEL_1233] (rows=550076554 width=110) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1230] (rows=550076554 width=110) - Conds:RS_1445._col0=RS_1387._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1232] (rows=550076554 width=110) + Conds:RS_1447._col0=RS_1389._col0(Inner),Output:["_col1","_col2"] <-Map 48 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1387] + SHUFFLE [RS_1389] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1380] + Please refer to the previous Select Operator [SEL_1382] <-Map 66 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1445] + SHUFFLE [RS_1447] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1444] + Please refer to the previous Select Operator [SEL_1446] <-Reducer 68 [CONTAINS] - Reduce Output Operator [RS_1253] - Group By Operator [GBY_1252] (rows=1 width=120) + Reduce Output Operator [RS_1255] + Group By Operator [GBY_1254] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1251] (rows=980593145 width=112) + Select Operator [SEL_1253] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1249] (rows=286549727 width=115) + Select Operator [SEL_1251] (rows=286549727 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1248] (rows=286549727 width=115) - Conds:RS_1460._col0=RS_1450._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1250] (rows=286549727 width=115) + Conds:RS_1462._col0=RS_1452._col0(Inner),Output:["_col1","_col2"] <-Map 71 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1450] + PARTITION_ONLY_SHUFFLE [RS_1452] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1449] + Please refer to the previous Select Operator [SEL_1451] <-Map 67 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1460] + SHUFFLE [RS_1462] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1459] + Please refer to the previous Select Operator [SEL_1461] <-Reducer 74 [CONTAINS] - Reduce Output Operator [RS_1271] - Group By Operator [GBY_1270] (rows=1 width=120) + Reduce Output Operator [RS_1273] + Group By Operator [GBY_1272] (rows=1 width=120) Output:["_col0","_col1"],aggregations:["sum(_col0)","count(_col0)"] - Select Operator [SEL_1269] (rows=980593145 width=112) + Select Operator [SEL_1271] (rows=980593145 width=112) Output:["_col0"] - Select Operator [SEL_1267] (rows=143966864 width=115) + Select Operator [SEL_1269] (rows=143966864 width=115) Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_1266] (rows=143966864 width=115) - Conds:RS_1475._col0=RS_1465._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_1268] (rows=143966864 width=115) + Conds:RS_1477._col0=RS_1467._col0(Inner),Output:["_col1","_col2"] <-Map 77 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_1465] + PARTITION_ONLY_SHUFFLE [RS_1467] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1464] + Please refer to the previous Select Operator [SEL_1466] <-Map 73 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_1475] + SHUFFLE [RS_1477] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_1474] + Please refer to the previous Select Operator [SEL_1476] diff --git ql/src/test/results/clientpositive/perf/tez/query15.q.out ql/src/test/results/clientpositive/perf/tez/query15.q.out index 3670a718b3..2edc99a7df 100644 --- ql/src/test/results/clientpositive/perf/tez/query15.q.out +++ ql/src/test/results/clientpositive/perf/tez/query15.q.out @@ -62,83 +62,83 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_99] - Limit [LIM_98] (rows=100 width=201) + File Output Operator [FS_104] + Limit [LIM_103] (rows=100 width=201) Number of rows:100 - Select Operator [SEL_97] (rows=10141 width=201) + Select Operator [SEL_102] (rows=10141 width=201) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] - Group By Operator [GBY_95] (rows=10141 width=201) + SHUFFLE [RS_101] + Group By Operator [GBY_100] (rows=10141 width=201) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col0 Group By Operator [GBY_24] (rows=2403417 width=201) Output:["_col0","_col1"],aggregations:["sum(_col8)"],keys:_col3 - Top N Key Operator [TNK_44] (rows=285117831 width=212) - keys:_col3,top n:100 - Select Operator [SEL_23] (rows=285117831 width=212) - Output:["_col3","_col8"] + Select Operator [SEL_23] (rows=285117831 width=212) + Output:["_col3","_col8"] + Top N Key Operator [TNK_47] (rows=285117831 width=212) + keys:_col3,top n:100 Filter Operator [FIL_22] (rows=285117831 width=212) predicate:(_col9 or _col4 or _col5) - Merge Join Operator [MERGEJOIN_77] (rows=285117831 width=212) + Merge Join Operator [MERGEJOIN_82] (rows=285117831 width=212) Conds:RS_19._col0=RS_20._col1(Inner),Output:["_col3","_col4","_col5","_col8","_col9"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_75] (rows=80000000 width=101) - Conds:RS_80._col1=RS_83._col0(Inner),Output:["_col0","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_80] (rows=80000000 width=101) + Conds:RS_85._col1=RS_88._col0(Inner),Output:["_col0","_col3","_col4","_col5"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_80] + SHUFFLE [RS_85] PartitionCols:_col1 - Select Operator [SEL_79] (rows=80000000 width=8) + Select Operator [SEL_84] (rows=80000000 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_78] (rows=80000000 width=8) + Filter Operator [FIL_83] (rows=80000000 width=8) predicate:(c_customer_sk is not null and c_current_addr_sk is not null) TableScan [TS_0] (rows=80000000 width=8) default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_83] + SHUFFLE [RS_88] PartitionCols:_col0 - Select Operator [SEL_82] (rows=40000000 width=101) + Select Operator [SEL_87] (rows=40000000 width=101) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_81] (rows=40000000 width=179) + Filter Operator [FIL_86] (rows=40000000 width=179) predicate:ca_address_sk is not null TableScan [TS_3] (rows=40000000 width=179) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_zip"] <-Reducer 8 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_76] (rows=285117831 width=119) - Conds:RS_94._col0=RS_86._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_81] (rows=285117831 width=119) + Conds:RS_99._col0=RS_91._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_86] + SHUFFLE [RS_91] PartitionCols:_col0 - Select Operator [SEL_85] (rows=130 width=4) + Select Operator [SEL_90] (rows=130 width=4) Output:["_col0"] - Filter Operator [FIL_84] (rows=130 width=12) + Filter Operator [FIL_89] (rows=130 width=12) predicate:((d_year = 2000) and (d_qoy = 2) and d_date_sk is not null) TableScan [TS_9] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_94] + SHUFFLE [RS_99] PartitionCols:_col0 - Select Operator [SEL_93] (rows=285117831 width=123) + Select Operator [SEL_98] (rows=285117831 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_92] (rows=285117831 width=119) + Filter Operator [FIL_97] (rows=285117831 width=119) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) TableScan [TS_6] (rows=287989836 width=119) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_sales_price"] <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_91] - Group By Operator [GBY_90] (rows=1 width=12) + BROADCAST [RS_96] + Group By Operator [GBY_95] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_89] - Group By Operator [GBY_88] (rows=1 width=12) + SHUFFLE [RS_94] + Group By Operator [GBY_93] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_87] (rows=130 width=4) + Select Operator [SEL_92] (rows=130 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_85] + Please refer to the previous Select Operator [SEL_90] diff --git ql/src/test/results/clientpositive/perf/tez/query17.q.out ql/src/test/results/clientpositive/perf/tez/query17.q.out index df70fbc46e..5b99aaac18 100644 --- ql/src/test/results/clientpositive/perf/tez/query17.q.out +++ ql/src/test/results/clientpositive/perf/tez/query17.q.out @@ -122,148 +122,148 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_253] - Limit [LIM_252] (rows=100 width=466) + File Output Operator [FS_258] + Limit [LIM_257] (rows=100 width=466) Number of rows:100 - Select Operator [SEL_251] (rows=97302218447 width=466) + Select Operator [SEL_256] (rows=97302218447 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_250] - Select Operator [SEL_249] (rows=97302218447 width=466) + SHUFFLE [RS_255] + Select Operator [SEL_254] (rows=97302218447 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] - Group By Operator [GBY_248] (rows=97302218447 width=466) + Group By Operator [GBY_253] (rows=97302218447 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","count(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","count(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_50] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_49] (rows=97302218447 width=466) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["count(_col3)","sum(_col3)","sum(_col7)","sum(_col6)","count(_col4)","sum(_col4)","sum(_col9)","sum(_col8)","count(_col5)","sum(_col5)","sum(_col11)","sum(_col10)"],keys:_col0, _col1, _col2 - Top N Key Operator [TNK_93] (rows=97302218447 width=381) - keys:_col0, _col1, _col2,top n:100 - Select Operator [SEL_47] (rows=97302218447 width=381) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - Merge Join Operator [MERGEJOIN_213] (rows=97302218447 width=381) - Conds:RS_44._col3=RS_247._col0(Inner),Output:["_col5","_col8","_col9","_col13","_col19","_col22"] + Select Operator [SEL_47] (rows=97302218447 width=381) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + Top N Key Operator [TNK_96] (rows=97302218447 width=381) + keys:_col8, _col9, _col22,top n:100 + Merge Join Operator [MERGEJOIN_218] (rows=97302218447 width=381) + Conds:RS_44._col3=RS_252._col0(Inner),Output:["_col5","_col8","_col9","_col13","_col19","_col22"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_247] + SHUFFLE [RS_252] PartitionCols:_col0 - Select Operator [SEL_246] (rows=1704 width=90) + Select Operator [SEL_251] (rows=1704 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_245] (rows=1704 width=90) + Filter Operator [FIL_250] (rows=1704 width=90) predicate:s_store_sk is not null TableScan [TS_32] (rows=1704 width=90) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_212] (rows=97302218447 width=299) + Merge Join Operator [MERGEJOIN_217] (rows=97302218447 width=299) Conds:RS_41._col1, _col2, _col4=RS_42._col6, _col7, _col8(Inner),Output:["_col3","_col5","_col8","_col9","_col13","_col19"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_42] PartitionCols:_col6, _col7, _col8 - Merge Join Operator [MERGEJOIN_211] (rows=10910732684 width=19) + Merge Join Operator [MERGEJOIN_216] (rows=10910732684 width=19) Conds:RS_28._col2, _col1=RS_29._col1, _col2(Inner),Output:["_col3","_col6","_col7","_col8","_col9"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col2, _col1 - Merge Join Operator [MERGEJOIN_209] (rows=285117831 width=11) - Conds:RS_241._col0=RS_222._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_214] (rows=285117831 width=11) + Conds:RS_246._col0=RS_227._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_222] + PARTITION_ONLY_SHUFFLE [RS_227] PartitionCols:_col0 - Select Operator [SEL_218] (rows=304 width=4) + Select Operator [SEL_223] (rows=304 width=4) Output:["_col0"] - Filter Operator [FIL_215] (rows=304 width=94) + Filter Operator [FIL_220] (rows=304 width=94) predicate:((d_quarter_name) IN ('2000Q1', '2000Q2', '2000Q3') and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=94) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_quarter_name"] <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_241] + SHUFFLE [RS_246] PartitionCols:_col0 - Select Operator [SEL_240] (rows=285117831 width=15) + Select Operator [SEL_245] (rows=285117831 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_239] (rows=285117831 width=15) + Filter Operator [FIL_244] (rows=285117831 width=15) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_26_d3_d_date_sk_min) AND DynamicValue(RS_26_d3_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_26_d3_d_date_sk_bloom_filter))) TableScan [TS_9] (rows=287989836 width=15) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_quantity"] <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_238] - Group By Operator [GBY_237] (rows=1 width=12) + BROADCAST [RS_243] + Group By Operator [GBY_242] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_228] - Group By Operator [GBY_226] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_233] + Group By Operator [GBY_231] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_223] (rows=304 width=4) + Select Operator [SEL_228] (rows=304 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_218] + Please refer to the previous Select Operator [SEL_223] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_210] (rows=53632139 width=15) - Conds:RS_244._col0=RS_224._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_215] (rows=53632139 width=15) + Conds:RS_249._col0=RS_229._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_224] + PARTITION_ONLY_SHUFFLE [RS_229] PartitionCols:_col0 - Select Operator [SEL_219] (rows=304 width=4) + Select Operator [SEL_224] (rows=304 width=4) Output:["_col0"] - Filter Operator [FIL_216] (rows=304 width=94) + Filter Operator [FIL_221] (rows=304 width=94) predicate:((d_quarter_name) IN ('2000Q1', '2000Q2', '2000Q3') and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_244] + SHUFFLE [RS_249] PartitionCols:_col0 - Select Operator [SEL_243] (rows=53632139 width=19) + Select Operator [SEL_248] (rows=53632139 width=19) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_242] (rows=53632139 width=19) + Filter Operator [FIL_247] (rows=53632139 width=19) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null and sr_item_sk is not null and sr_ticket_number is not null) TableScan [TS_15] (rows=57591150 width=19) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number","sr_return_quantity"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_41] PartitionCols:_col1, _col2, _col4 - Merge Join Operator [MERGEJOIN_208] (rows=501694138 width=303) - Conds:RS_38._col1=RS_236._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col8","_col9"] + Merge Join Operator [MERGEJOIN_213] (rows=501694138 width=303) + Conds:RS_38._col1=RS_241._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col8","_col9"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_236] + SHUFFLE [RS_241] PartitionCols:_col0 - Select Operator [SEL_235] (rows=462000 width=288) + Select Operator [SEL_240] (rows=462000 width=288) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_234] (rows=462000 width=288) + Filter Operator [FIL_239] (rows=462000 width=288) predicate:i_item_sk is not null TableScan [TS_6] (rows=462000 width=288) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_38] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_207] (rows=501694138 width=19) - Conds:RS_233._col0=RS_220._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_212] (rows=501694138 width=19) + Conds:RS_238._col0=RS_225._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_220] + PARTITION_ONLY_SHUFFLE [RS_225] PartitionCols:_col0 - Select Operator [SEL_217] (rows=101 width=4) + Select Operator [SEL_222] (rows=101 width=4) Output:["_col0"] - Filter Operator [FIL_214] (rows=101 width=94) + Filter Operator [FIL_219] (rows=101 width=94) predicate:((d_quarter_name = '2000Q1') and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_233] + SHUFFLE [RS_238] PartitionCols:_col0 - Select Operator [SEL_232] (rows=501694138 width=23) + Select Operator [SEL_237] (rows=501694138 width=23) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_231] (rows=501694138 width=23) + Filter Operator [FIL_236] (rows=501694138 width=23) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_ticket_number is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_36_d1_d_date_sk_min) AND DynamicValue(RS_36_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_36_d1_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=23) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_quantity"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_230] - Group By Operator [GBY_229] (rows=1 width=12) + BROADCAST [RS_235] + Group By Operator [GBY_234] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_227] - Group By Operator [GBY_225] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_232] + Group By Operator [GBY_230] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_221] (rows=101 width=4) + Select Operator [SEL_226] (rows=101 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_217] + Please refer to the previous Select Operator [SEL_222] diff --git ql/src/test/results/clientpositive/perf/tez/query18.q.out ql/src/test/results/clientpositive/perf/tez/query18.q.out index d61a57d469..47c55deeaa 100644 --- ql/src/test/results/clientpositive/perf/tez/query18.q.out +++ ql/src/test/results/clientpositive/perf/tez/query18.q.out @@ -97,123 +97,125 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_174] - Limit [LIM_173] (rows=100 width=1165) + File Output Operator [FS_176] + Limit [LIM_175] (rows=100 width=1165) Number of rows:100 - Select Operator [SEL_172] (rows=81128925 width=1165) + Select Operator [SEL_174] (rows=81128925 width=1165) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_171] - Select Operator [SEL_170] (rows=81128925 width=1165) + SHUFFLE [RS_173] + Select Operator [SEL_172] (rows=81128925 width=1165) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - Group By Operator [GBY_169] (rows=81128925 width=1229) - Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)","sum(VALUE._col8)","count(VALUE._col9)","sum(VALUE._col10)","count(VALUE._col11)","sum(VALUE._col12)","count(VALUE._col13)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_42] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_41] (rows=81128925 width=1229) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(_col15)","count(_col15)","sum(_col16)","count(_col16)","sum(_col17)","count(_col17)","sum(_col18)","count(_col18)","sum(_col19)","count(_col19)","sum(_col3)","count(_col3)","sum(_col22)","count(_col22)"],keys:_col5, _col6, _col7, _col10, 0L - Merge Join Operator [MERGEJOIN_142] (rows=16225785 width=1117) - Conds:RS_37._col0=RS_38._col3(Inner),Output:["_col3","_col5","_col6","_col7","_col10","_col15","_col16","_col17","_col18","_col19","_col22"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_38] - PartitionCols:_col3 - Select Operator [SEL_30] (rows=16225785 width=736) - Output:["_col1","_col3","_col6","_col7","_col8","_col9","_col10","_col13"] - Merge Join Operator [MERGEJOIN_141] (rows=16225785 width=736) - Conds:RS_27._col3=RS_168._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col8","_col11","_col13"] - <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_168] + Top N Key Operator [TNK_171] (rows=81128925 width=1229) + keys:_col2, _col1, _col0, _col3,top n:100 + Group By Operator [GBY_170] (rows=81128925 width=1229) + Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)","sum(VALUE._col8)","count(VALUE._col9)","sum(VALUE._col10)","count(VALUE._col11)","sum(VALUE._col12)","count(VALUE._col13)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_42] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_41] (rows=81128925 width=1229) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18"],aggregations:["sum(_col15)","count(_col15)","sum(_col16)","count(_col16)","sum(_col17)","count(_col17)","sum(_col18)","count(_col18)","sum(_col19)","count(_col19)","sum(_col3)","count(_col3)","sum(_col22)","count(_col22)"],keys:_col5, _col6, _col7, _col10, 0L + Merge Join Operator [MERGEJOIN_143] (rows=16225785 width=1117) + Conds:RS_37._col0=RS_38._col3(Inner),Output:["_col3","_col5","_col6","_col7","_col10","_col15","_col16","_col17","_col18","_col19","_col22"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_38] + PartitionCols:_col3 + Select Operator [SEL_30] (rows=16225785 width=736) + Output:["_col1","_col3","_col6","_col7","_col8","_col9","_col10","_col13"] + Merge Join Operator [MERGEJOIN_142] (rows=16225785 width=736) + Conds:RS_27._col3=RS_169._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col8","_col11","_col13"] + <-Map 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_169] + PartitionCols:_col0 + Select Operator [SEL_168] (rows=462000 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_167] (rows=462000 width=104) + predicate:i_item_sk is not null + TableScan [TS_18] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_141] (rows=16225785 width=640) + Conds:RS_24._col2=RS_166._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_166] + PartitionCols:_col0 + Select Operator [SEL_165] (rows=103434 width=116) + Output:["_col0","_col1"] + Filter Operator [FIL_164] (rows=103434 width=187) + predicate:((cd_education_status = 'College') and (cd_gender = 'M') and cd_demo_sk is not null) + TableScan [TS_15] (rows=1861800 width=187) + default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_education_status","cd_dep_count"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_140] (rows=283692098 width=569) + Conds:RS_163._col0=RS_155._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + <-Map 13 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_155] + PartitionCols:_col0 + Select Operator [SEL_154] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_153] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + TableScan [TS_12] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_163] + PartitionCols:_col0 + Select Operator [SEL_162] (rows=283692098 width=573) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_161] (rows=283692098 width=466) + predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_9] (rows=287989836 width=466) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_bill_cdemo_sk","cs_item_sk","cs_quantity","cs_list_price","cs_sales_price","cs_coupon_amt","cs_net_profit"] + <-Reducer 14 [BROADCAST_EDGE] vectorized + BROADCAST [RS_160] + Group By Operator [GBY_159] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_158] + Group By Operator [GBY_157] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_156] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_154] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_139] (rows=4959744 width=368) + Conds:RS_34._col1=RS_152._col0(Inner),Output:["_col0","_col3","_col5","_col6","_col7"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_152] PartitionCols:_col0 - Select Operator [SEL_167] (rows=462000 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_166] (rows=462000 width=104) - predicate:i_item_sk is not null - TableScan [TS_18] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_140] (rows=16225785 width=640) - Conds:RS_24._col2=RS_165._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_165] - PartitionCols:_col0 - Select Operator [SEL_164] (rows=103434 width=116) - Output:["_col0","_col1"] - Filter Operator [FIL_163] (rows=103434 width=187) - predicate:((cd_education_status = 'College') and (cd_gender = 'M') and cd_demo_sk is not null) - TableScan [TS_15] (rows=1861800 width=187) - default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_education_status","cd_dep_count"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_24] + Select Operator [SEL_151] (rows=1861800 width=4) + Output:["_col0"] + Filter Operator [FIL_150] (rows=1861800 width=4) + predicate:cd_demo_sk is not null + TableScan [TS_6] (rows=1861800 width=4) + default@customer_demographics,cd2,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_138] (rows=4890586 width=371) + Conds:RS_146._col2=RS_149._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6","_col7"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_146] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_139] (rows=283692098 width=569) - Conds:RS_162._col0=RS_154._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Map 13 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_154] - PartitionCols:_col0 - Select Operator [SEL_153] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_152] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - TableScan [TS_12] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_162] - PartitionCols:_col0 - Select Operator [SEL_161] (rows=283692098 width=573) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_160] (rows=283692098 width=466) - predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_9] (rows=287989836 width=466) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_bill_cdemo_sk","cs_item_sk","cs_quantity","cs_list_price","cs_sales_price","cs_coupon_amt","cs_net_profit"] - <-Reducer 14 [BROADCAST_EDGE] vectorized - BROADCAST [RS_159] - Group By Operator [GBY_158] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_157] - Group By Operator [GBY_156] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_155] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_153] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_138] (rows=4959744 width=368) - Conds:RS_34._col1=RS_151._col0(Inner),Output:["_col0","_col3","_col5","_col6","_col7"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_151] - PartitionCols:_col0 - Select Operator [SEL_150] (rows=1861800 width=4) - Output:["_col0"] - Filter Operator [FIL_149] (rows=1861800 width=4) - predicate:cd_demo_sk is not null - TableScan [TS_6] (rows=1861800 width=4) - default@customer_demographics,cd2,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_137] (rows=4890586 width=371) - Conds:RS_145._col2=RS_148._col0(Inner),Output:["_col0","_col1","_col3","_col5","_col6","_col7"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_145] - PartitionCols:_col2 - Select Operator [SEL_144] (rows=35631408 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_143] (rows=35631408 width=19) - predicate:((c_birth_month) IN (9, 5, 12, 4, 1, 10) and c_current_cdemo_sk is not null and c_customer_sk is not null and c_current_addr_sk is not null) - TableScan [TS_0] (rows=80000000 width=19) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk","c_birth_month","c_birth_year"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=5490196 width=285) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_146] (rows=5490196 width=285) - predicate:((ca_state) IN ('ND', 'WI', 'AL', 'NC', 'OK', 'MS', 'TN') and ca_address_sk is not null) - TableScan [TS_3] (rows=40000000 width=285) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state","ca_country"] + Select Operator [SEL_145] (rows=35631408 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_144] (rows=35631408 width=19) + predicate:((c_birth_month) IN (9, 5, 12, 4, 1, 10) and c_current_cdemo_sk is not null and c_customer_sk is not null and c_current_addr_sk is not null) + TableScan [TS_0] (rows=80000000 width=19) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk","c_birth_month","c_birth_year"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=5490196 width=285) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_147] (rows=5490196 width=285) + predicate:((ca_state) IN ('ND', 'WI', 'AL', 'NC', 'OK', 'MS', 'TN') and ca_address_sk is not null) + TableScan [TS_3] (rows=40000000 width=285) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state","ca_country"] diff --git ql/src/test/results/clientpositive/perf/tez/query19.q.out ql/src/test/results/clientpositive/perf/tez/query19.q.out index 5cdeab2bf0..55ce9447a3 100644 --- ql/src/test/results/clientpositive/perf/tez/query19.q.out +++ ql/src/test/results/clientpositive/perf/tez/query19.q.out @@ -78,111 +78,113 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_152] - Limit [LIM_151] (rows=100 width=419) + File Output Operator [FS_154] + Limit [LIM_153] (rows=100 width=419) Number of rows:100 - Select Operator [SEL_150] (rows=76645658 width=418) + Select Operator [SEL_152] (rows=76645658 width=418) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_149] - Select Operator [SEL_148] (rows=76645658 width=418) + SHUFFLE [RS_151] + Select Operator [SEL_150] (rows=76645658 width=418) Output:["_col2","_col3","_col4","_col5","_col6"] - Group By Operator [GBY_147] (rows=76645658 width=314) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_36] (rows=76645658 width=314) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)"],keys:_col12, _col11, _col13, _col14 - Select Operator [SEL_35] (rows=76645658 width=650) - Output:["_col8","_col11","_col12","_col13","_col14"] - Filter Operator [FIL_34] (rows=76645658 width=650) - predicate:(_col3 <> _col16) - Merge Join Operator [MERGEJOIN_123] (rows=76645658 width=650) - Conds:RS_31._col7=RS_146._col0(Inner),Output:["_col3","_col8","_col11","_col12","_col13","_col14","_col16"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - PartitionCols:_col0 - Select Operator [SEL_145] (rows=1704 width=188) - Output:["_col0","_col1"] - Filter Operator [FIL_144] (rows=1704 width=93) - predicate:s_store_sk is not null - TableScan [TS_22] (rows=1704 width=93) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_zip"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col7 - Merge Join Operator [MERGEJOIN_122] (rows=76645658 width=468) - Conds:RS_28._col0=RS_29._col2(Inner),Output:["_col3","_col7","_col8","_col11","_col12","_col13","_col14"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_121] (rows=76645658 width=287) - Conds:RS_18._col1=RS_143._col0(Inner),Output:["_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_143] - PartitionCols:_col0 - Select Operator [SEL_142] (rows=7333 width=206) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_141] (rows=7333 width=210) - predicate:((i_manager_id = 7) and i_item_sk is not null) - TableScan [TS_12] (rows=462000 width=210) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id","i_manufact","i_manager_id"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_120] (rows=501694138 width=118) - Conds:RS_140._col0=RS_132._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_132] - PartitionCols:_col0 - Select Operator [SEL_131] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_130] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 11) and d_date_sk is not null) - TableScan [TS_9] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_140] - PartitionCols:_col0 - Select Operator [SEL_139] (rows=501694138 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_138] (rows=501694138 width=122) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_6] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ext_sales_price"] - <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_137] - Group By Operator [GBY_136] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_135] - Group By Operator [GBY_134] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_133] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_131] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_28] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_119] (rows=80000000 width=188) - Conds:RS_126._col1=RS_129._col0(Inner),Output:["_col0","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_126] - PartitionCols:_col1 - Select Operator [SEL_125] (rows=80000000 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_124] (rows=80000000 width=8) - predicate:(c_customer_sk is not null and c_current_addr_sk is not null) - TableScan [TS_0] (rows=80000000 width=8) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_129] - PartitionCols:_col0 - Select Operator [SEL_128] (rows=40000000 width=188) - Output:["_col0","_col1"] - Filter Operator [FIL_127] (rows=40000000 width=93) - predicate:ca_address_sk is not null - TableScan [TS_3] (rows=40000000 width=93) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_zip"] + Top N Key Operator [TNK_149] (rows=76645658 width=314) + keys:_col4, _col0, _col1, _col2, _col3,top n:100 + Group By Operator [GBY_148] (rows=76645658 width=314) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_36] (rows=76645658 width=314) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)"],keys:_col12, _col11, _col13, _col14 + Select Operator [SEL_35] (rows=76645658 width=650) + Output:["_col8","_col11","_col12","_col13","_col14"] + Filter Operator [FIL_34] (rows=76645658 width=650) + predicate:(_col3 <> _col16) + Merge Join Operator [MERGEJOIN_124] (rows=76645658 width=650) + Conds:RS_31._col7=RS_147._col0(Inner),Output:["_col3","_col8","_col11","_col12","_col13","_col14","_col16"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_147] + PartitionCols:_col0 + Select Operator [SEL_146] (rows=1704 width=188) + Output:["_col0","_col1"] + Filter Operator [FIL_145] (rows=1704 width=93) + predicate:s_store_sk is not null + TableScan [TS_22] (rows=1704 width=93) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_zip"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col7 + Merge Join Operator [MERGEJOIN_123] (rows=76645658 width=468) + Conds:RS_28._col0=RS_29._col2(Inner),Output:["_col3","_col7","_col8","_col11","_col12","_col13","_col14"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_122] (rows=76645658 width=287) + Conds:RS_18._col1=RS_144._col0(Inner),Output:["_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_144] + PartitionCols:_col0 + Select Operator [SEL_143] (rows=7333 width=206) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_142] (rows=7333 width=210) + predicate:((i_manager_id = 7) and i_item_sk is not null) + TableScan [TS_12] (rows=462000 width=210) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id","i_manufact","i_manager_id"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_121] (rows=501694138 width=118) + Conds:RS_141._col0=RS_133._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_133] + PartitionCols:_col0 + Select Operator [SEL_132] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_131] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 11) and d_date_sk is not null) + TableScan [TS_9] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_141] + PartitionCols:_col0 + Select Operator [SEL_140] (rows=501694138 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_139] (rows=501694138 width=122) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_6] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ext_sales_price"] + <-Reducer 12 [BROADCAST_EDGE] vectorized + BROADCAST [RS_138] + Group By Operator [GBY_137] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_136] + Group By Operator [GBY_135] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_134] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_132] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_28] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_120] (rows=80000000 width=188) + Conds:RS_127._col1=RS_130._col0(Inner),Output:["_col0","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_127] + PartitionCols:_col1 + Select Operator [SEL_126] (rows=80000000 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_125] (rows=80000000 width=8) + predicate:(c_customer_sk is not null and c_current_addr_sk is not null) + TableScan [TS_0] (rows=80000000 width=8) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_130] + PartitionCols:_col0 + Select Operator [SEL_129] (rows=40000000 width=188) + Output:["_col0","_col1"] + Filter Operator [FIL_128] (rows=40000000 width=93) + predicate:ca_address_sk is not null + TableScan [TS_3] (rows=40000000 width=93) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_zip"] diff --git ql/src/test/results/clientpositive/perf/tez/query1b.q.out ql/src/test/results/clientpositive/perf/tez/query1b.q.out index b7975918c3..4b2ca4455c 100644 --- ql/src/test/results/clientpositive/perf/tez/query1b.q.out +++ ql/src/test/results/clientpositive/perf/tez/query1b.q.out @@ -307,16 +307,22 @@ STAGE PLANS: Filter Operator predicate: (_col3 > _col6) (type: boolean) Statistics: Num rows: 17457727 Data size: 5656303548 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col5 (type: string) - outputColumnNames: _col0 - Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + + Top N Key Operator + sort order: + + keys: _col5 (type: string) + null sort order: z + Statistics: Num rows: 17457727 Data size: 5656303548 Basic stats: COMPLETE Column stats: COMPLETE + top n: 100 + Select Operator + expressions: _col5 (type: string) + outputColumnNames: _col0 Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: z + sort order: + + Statistics: Num rows: 17457727 Data size: 1745772700 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reducer 6 Execution mode: vectorized Reduce Operator Tree: diff --git ql/src/test/results/clientpositive/perf/tez/query20.q.out ql/src/test/results/clientpositive/perf/tez/query20.q.out index 2553c1ed76..4def57d2eb 100644 --- ql/src/test/results/clientpositive/perf/tez/query20.q.out +++ ql/src/test/results/clientpositive/perf/tez/query20.q.out @@ -78,72 +78,74 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_81] - Limit [LIM_80] (rows=100 width=802) + File Output Operator [FS_83] + Limit [LIM_82] (rows=100 width=802) Number of rows:100 - Select Operator [SEL_79] (rows=138600 width=801) + Select Operator [SEL_81] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_78] - Select Operator [SEL_77] (rows=138600 width=801) + SHUFFLE [RS_80] + Select Operator [SEL_79] (rows=138600 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_76] (rows=138600 width=690) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] - Select Operator [SEL_75] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_74] - PartitionCols:_col1 - Group By Operator [GBY_73] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_16] (rows=138600 width=690) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_58] (rows=85964922 width=688) - Conds:RS_12._col1=RS_72._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_72] - PartitionCols:_col0 - Select Operator [SEL_71] (rows=138600 width=581) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_70] (rows=138600 width=581) - predicate:((i_category) IN ('Jewelry', 'Sports', 'Books') and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=581) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_57] (rows=286549727 width=115) - Conds:RS_69._col0=RS_61._col0(Inner),Output:["_col1","_col2"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_61] - PartitionCols:_col0 - Select Operator [SEL_60] (rows=8116 width=4) - Output:["_col0"] - Filter Operator [FIL_59] (rows=8116 width=98) - predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=286549727 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_67] (rows=286549727 width=119) - predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=287989836 width=119) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_66] - Group By Operator [GBY_65] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_64] - Group By Operator [GBY_63] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_62] (rows=8116 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_60] + Top N Key Operator [TNK_78] (rows=138600 width=690) + keys:_col0, _col1, _col2, _col3, ((_col5 * 100) / sum_window_0),top n:100 + PTF Operator [PTF_77] (rows=138600 width=690) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST","partition by:":"_col1"}] + Select Operator [SEL_76] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_75] + PartitionCols:_col1 + Group By Operator [GBY_74] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_16] (rows=138600 width=690) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)"],keys:_col9, _col8, _col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_59] (rows=85964922 width=688) + Conds:RS_12._col1=RS_73._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_73] + PartitionCols:_col0 + Select Operator [SEL_72] (rows=138600 width=581) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_71] (rows=138600 width=581) + predicate:((i_category) IN ('Jewelry', 'Sports', 'Books') and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=581) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_class","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_58] (rows=286549727 width=115) + Conds:RS_70._col0=RS_62._col0(Inner),Output:["_col1","_col2"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_62] + PartitionCols:_col0 + Select Operator [SEL_61] (rows=8116 width=4) + Output:["_col0"] + Filter Operator [FIL_60] (rows=8116 width=98) + predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-01-12 00:00:00' AND TIMESTAMP'2001-02-11 00:00:00' and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_70] + PartitionCols:_col0 + Select Operator [SEL_69] (rows=286549727 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_68] (rows=286549727 width=119) + predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=287989836 width=119) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_67] + Group By Operator [GBY_66] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_65] + Group By Operator [GBY_64] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_63] (rows=8116 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_61] diff --git ql/src/test/results/clientpositive/perf/tez/query21.q.out ql/src/test/results/clientpositive/perf/tez/query21.q.out index 5e158834d7..08e4828dc2 100644 --- ql/src/test/results/clientpositive/perf/tez/query21.q.out +++ ql/src/test/results/clientpositive/perf/tez/query21.q.out @@ -80,70 +80,72 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_95] - Limit [LIM_94] (rows=100 width=216) + File Output Operator [FS_97] + Limit [LIM_96] (rows=100 width=216) Number of rows:100 - Select Operator [SEL_93] (rows=115991 width=216) + Select Operator [SEL_95] (rows=115991 width=216) Output:["_col0","_col1","_col2","_col3"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] - Filter Operator [FIL_91] (rows=115991 width=216) - predicate:(CASE WHEN ((_col2 > 0L)) THEN ((0.666667D <= (UDFToDouble(_col3) / UDFToDouble(_col2)))) ELSE (false) END and CASE WHEN ((_col2 > 0L)) THEN (((UDFToDouble(_col3) / UDFToDouble(_col2)) <= 1.5D)) ELSE (false) END) - Group By Operator [GBY_90] (rows=463966 width=216) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:_col0, _col1 - Group By Operator [GBY_23] (rows=463966 width=216) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1 - Select Operator [SEL_21] (rows=463966 width=208) - Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_77] (rows=463966 width=208) - Conds:RS_18._col2=RS_89._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_89] - PartitionCols:_col0 - Select Operator [SEL_88] (rows=27 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_87] (rows=27 width=104) - predicate:w_warehouse_sk is not null - TableScan [TS_9] (rows=27 width=104) - default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_76] (rows=463966 width=112) - Conds:RS_15._col1=RS_86._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_86] - PartitionCols:_col0 - Select Operator [SEL_85] (rows=51333 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_84] (rows=51333 width=215) - predicate:(i_current_price BETWEEN 0.99 AND 1.49 and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=215) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_current_price"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_75] (rows=4175715 width=18) - Conds:RS_80._col0=RS_83._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_80] - PartitionCols:_col0 - Select Operator [SEL_79] (rows=37584000 width=15) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_78] (rows=37584000 width=15) - predicate:(inv_warehouse_sk is not null and inv_item_sk is not null and inv_date_sk is not null) - TableScan [TS_0] (rows=37584000 width=15) - default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_83] - PartitionCols:_col0 - Select Operator [SEL_82] (rows=8116 width=12) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_81] (rows=8116 width=98) - predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-03-09 00:00:00' AND TIMESTAMP'1998-05-08 00:00:00' and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + SHUFFLE [RS_94] + Top N Key Operator [TNK_93] (rows=115991 width=216) + keys:_col0, _col1,top n:100 + Filter Operator [FIL_92] (rows=115991 width=216) + predicate:(CASE WHEN ((_col2 > 0L)) THEN ((0.666667D <= (UDFToDouble(_col3) / UDFToDouble(_col2)))) ELSE (false) END and CASE WHEN ((_col2 > 0L)) THEN (((UDFToDouble(_col3) / UDFToDouble(_col2)) <= 1.5D)) ELSE (false) END) + Group By Operator [GBY_91] (rows=463966 width=216) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col0, _col1 + Group By Operator [GBY_23] (rows=463966 width=216) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1 + Select Operator [SEL_21] (rows=463966 width=208) + Output:["_col0","_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_78] (rows=463966 width=208) + Conds:RS_18._col2=RS_90._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_90] + PartitionCols:_col0 + Select Operator [SEL_89] (rows=27 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_88] (rows=27 width=104) + predicate:w_warehouse_sk is not null + TableScan [TS_9] (rows=27 width=104) + default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_77] (rows=463966 width=112) + Conds:RS_15._col1=RS_87._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_87] + PartitionCols:_col0 + Select Operator [SEL_86] (rows=51333 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_85] (rows=51333 width=215) + predicate:(i_current_price BETWEEN 0.99 AND 1.49 and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=215) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_current_price"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_76] (rows=4175715 width=18) + Conds:RS_81._col0=RS_84._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_81] + PartitionCols:_col0 + Select Operator [SEL_80] (rows=37584000 width=15) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_79] (rows=37584000 width=15) + predicate:(inv_warehouse_sk is not null and inv_item_sk is not null and inv_date_sk is not null) + TableScan [TS_0] (rows=37584000 width=15) + default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_84] + PartitionCols:_col0 + Select Operator [SEL_83] (rows=8116 width=12) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_82] (rows=8116 width=98) + predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-03-09 00:00:00' AND TIMESTAMP'1998-05-08 00:00:00' and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] diff --git ql/src/test/results/clientpositive/perf/tez/query22.q.out ql/src/test/results/clientpositive/perf/tez/query22.q.out index e721f09f82..45a090267b 100644 --- ql/src/test/results/clientpositive/perf/tez/query22.q.out +++ ql/src/test/results/clientpositive/perf/tez/query22.q.out @@ -64,68 +64,70 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_93] - Limit [LIM_92] (rows=100 width=397) + File Output Operator [FS_95] + Limit [LIM_94] (rows=100 width=397) Number of rows:100 - Select Operator [SEL_91] (rows=32730675 width=397) + Select Operator [SEL_93] (rows=32730675 width=397) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_90] - Select Operator [SEL_89] (rows=32730675 width=397) + SHUFFLE [RS_92] + Select Operator [SEL_91] (rows=32730675 width=397) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_88] (rows=32730675 width=413) - Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_22] (rows=32730675 width=413) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)","count(_col3)"],keys:_col7, _col8, _col9, _col10, 0L - Merge Join Operator [MERGEJOIN_75] (rows=6546135 width=391) - Conds:RS_18._col1=RS_87._col0(Inner),Output:["_col3","_col7","_col8","_col9","_col10"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_87] - PartitionCols:_col0 - Select Operator [SEL_86] (rows=462000 width=393) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_85] (rows=462000 width=393) - predicate:i_item_sk is not null - TableScan [TS_9] (rows=462000 width=393) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_74] (rows=6546135 width=6) - Conds:RS_15._col2=RS_84._col0(Inner),Output:["_col1","_col3"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_84] - PartitionCols:_col0 - Select Operator [SEL_83] (rows=27 width=4) - Output:["_col0"] - Filter Operator [FIL_82] (rows=27 width=4) - predicate:w_warehouse_sk is not null - TableScan [TS_6] (rows=27 width=4) - default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_73] (rows=6546135 width=10) - Conds:RS_78._col0=RS_81._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_78] - PartitionCols:_col0 - Select Operator [SEL_77] (rows=37584000 width=15) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_76] (rows=37584000 width=15) - predicate:(inv_date_sk is not null and inv_item_sk is not null and inv_warehouse_sk is not null) - TableScan [TS_0] (rows=37584000 width=15) - default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_81] - PartitionCols:_col0 - Select Operator [SEL_80] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_79] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + Top N Key Operator [TNK_90] (rows=32730675 width=413) + keys:(UDFToDouble(_col5) / _col6), _col3, _col0, _col1, _col2,top n:100 + Group By Operator [GBY_89] (rows=32730675 width=413) + Output:["_col0","_col1","_col2","_col3","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_22] (rows=32730675 width=413) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)","count(_col3)"],keys:_col7, _col8, _col9, _col10, 0L + Merge Join Operator [MERGEJOIN_76] (rows=6546135 width=391) + Conds:RS_18._col1=RS_88._col0(Inner),Output:["_col3","_col7","_col8","_col9","_col10"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_88] + PartitionCols:_col0 + Select Operator [SEL_87] (rows=462000 width=393) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_86] (rows=462000 width=393) + predicate:i_item_sk is not null + TableScan [TS_9] (rows=462000 width=393) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_75] (rows=6546135 width=6) + Conds:RS_15._col2=RS_85._col0(Inner),Output:["_col1","_col3"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_85] + PartitionCols:_col0 + Select Operator [SEL_84] (rows=27 width=4) + Output:["_col0"] + Filter Operator [FIL_83] (rows=27 width=4) + predicate:w_warehouse_sk is not null + TableScan [TS_6] (rows=27 width=4) + default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_74] (rows=6546135 width=10) + Conds:RS_79._col0=RS_82._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_79] + PartitionCols:_col0 + Select Operator [SEL_78] (rows=37584000 width=15) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_77] (rows=37584000 width=15) + predicate:(inv_date_sk is not null and inv_item_sk is not null and inv_warehouse_sk is not null) + TableScan [TS_0] (rows=37584000 width=15) + default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_82] + PartitionCols:_col0 + Select Operator [SEL_81] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_80] (rows=317 width=8) + predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] diff --git ql/src/test/results/clientpositive/perf/tez/query25.q.out ql/src/test/results/clientpositive/perf/tez/query25.q.out index d006795c79..149f395f40 100644 --- ql/src/test/results/clientpositive/perf/tez/query25.q.out +++ ql/src/test/results/clientpositive/perf/tez/query25.q.out @@ -128,144 +128,144 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_253] - Limit [LIM_252] (rows=100 width=808) + File Output Operator [FS_258] + Limit [LIM_257] (rows=100 width=808) Number of rows:100 - Select Operator [SEL_251] (rows=97302218447 width=808) + Select Operator [SEL_256] (rows=97302218447 width=808) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_250] - Group By Operator [GBY_249] (rows=97302218447 width=808) + SHUFFLE [RS_255] + Group By Operator [GBY_254] (rows=97302218447 width=808) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_49] PartitionCols:_col0, _col1, _col2, _col3 Group By Operator [GBY_48] (rows=97302218447 width=808) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col5)","sum(_col16)","sum(_col10)"],keys:_col19, _col20, _col22, _col23 - Top N Key Operator [TNK_95] (rows=97302218447 width=807) + Top N Key Operator [TNK_98] (rows=97302218447 width=807) keys:_col19, _col20, _col22, _col23,top n:100 - Merge Join Operator [MERGEJOIN_214] (rows=97302218447 width=807) - Conds:RS_44._col3=RS_248._col0(Inner),Output:["_col5","_col10","_col16","_col19","_col20","_col22","_col23"] + Merge Join Operator [MERGEJOIN_219] (rows=97302218447 width=807) + Conds:RS_44._col3=RS_253._col0(Inner),Output:["_col5","_col10","_col16","_col19","_col20","_col22","_col23"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_248] + SHUFFLE [RS_253] PartitionCols:_col0 - Select Operator [SEL_247] (rows=1704 width=192) + Select Operator [SEL_252] (rows=1704 width=192) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_246] (rows=1704 width=192) + Filter Operator [FIL_251] (rows=1704 width=192) predicate:s_store_sk is not null TableScan [TS_32] (rows=1704 width=192) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_213] (rows=97302218447 width=623) - Conds:RS_41._col1=RS_245._col0(Inner),Output:["_col3","_col5","_col10","_col16","_col19","_col20"] + Merge Join Operator [MERGEJOIN_218] (rows=97302218447 width=623) + Conds:RS_41._col1=RS_250._col0(Inner),Output:["_col3","_col5","_col10","_col16","_col19","_col20"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_245] + SHUFFLE [RS_250] PartitionCols:_col0 - Select Operator [SEL_244] (rows=462000 width=288) + Select Operator [SEL_249] (rows=462000 width=288) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_243] (rows=462000 width=288) + Filter Operator [FIL_248] (rows=462000 width=288) predicate:i_item_sk is not null TableScan [TS_29] (rows=462000 width=288) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_41] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_212] (rows=97302218447 width=343) + Merge Join Operator [MERGEJOIN_217] (rows=97302218447 width=343) Conds:RS_38._col1, _col2, _col4=RS_39._col6, _col7, _col8(Inner),Output:["_col1","_col3","_col5","_col10","_col16"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_39] PartitionCols:_col6, _col7, _col8 - Merge Join Operator [MERGEJOIN_211] (rows=10910732684 width=235) + Merge Join Operator [MERGEJOIN_216] (rows=10910732684 width=235) Conds:RS_25._col2, _col1=RS_26._col1, _col2(Inner),Output:["_col3","_col6","_col7","_col8","_col9"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col2, _col1 - Merge Join Operator [MERGEJOIN_209] (rows=285117831 width=119) - Conds:RS_239._col0=RS_223._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_214] (rows=285117831 width=119) + Conds:RS_244._col0=RS_228._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_223] + PARTITION_ONLY_SHUFFLE [RS_228] PartitionCols:_col0 - Select Operator [SEL_219] (rows=351 width=4) + Select Operator [SEL_224] (rows=351 width=4) Output:["_col0"] - Filter Operator [FIL_216] (rows=351 width=12) + Filter Operator [FIL_221] (rows=351 width=12) predicate:((d_year = 2000) and d_moy BETWEEN 4 AND 10 and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=12) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] + SHUFFLE [RS_244] PartitionCols:_col0 - Select Operator [SEL_238] (rows=285117831 width=123) + Select Operator [SEL_243] (rows=285117831 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_237] (rows=285117831 width=123) + Filter Operator [FIL_242] (rows=285117831 width=123) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_23_d3_d_date_sk_min) AND DynamicValue(RS_23_d3_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_23_d3_d_date_sk_bloom_filter))) TableScan [TS_6] (rows=287989836 width=123) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_net_profit"] <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_236] - Group By Operator [GBY_235] (rows=1 width=12) + BROADCAST [RS_241] + Group By Operator [GBY_240] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_229] - Group By Operator [GBY_227] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_234] + Group By Operator [GBY_232] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_224] (rows=351 width=4) + Select Operator [SEL_229] (rows=351 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_219] + Please refer to the previous Select Operator [SEL_224] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_26] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_210] (rows=53632139 width=119) - Conds:RS_242._col0=RS_225._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_215] (rows=53632139 width=119) + Conds:RS_247._col0=RS_230._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_225] + PARTITION_ONLY_SHUFFLE [RS_230] PartitionCols:_col0 - Select Operator [SEL_220] (rows=351 width=4) + Select Operator [SEL_225] (rows=351 width=4) Output:["_col0"] - Filter Operator [FIL_217] (rows=351 width=12) + Filter Operator [FIL_222] (rows=351 width=12) predicate:((d_year = 2000) and d_moy BETWEEN 4 AND 10 and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_242] + SHUFFLE [RS_247] PartitionCols:_col0 - Select Operator [SEL_241] (rows=53632139 width=123) + Select Operator [SEL_246] (rows=53632139 width=123) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_240] (rows=53632139 width=123) + Filter Operator [FIL_245] (rows=53632139 width=123) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null and sr_item_sk is not null and sr_ticket_number is not null) TableScan [TS_12] (rows=57591150 width=123) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number","sr_net_loss"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_38] PartitionCols:_col1, _col2, _col4 - Merge Join Operator [MERGEJOIN_208] (rows=501694138 width=122) - Conds:RS_234._col0=RS_221._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_213] (rows=501694138 width=122) + Conds:RS_239._col0=RS_226._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_221] + PARTITION_ONLY_SHUFFLE [RS_226] PartitionCols:_col0 - Select Operator [SEL_218] (rows=50 width=4) + Select Operator [SEL_223] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_215] (rows=50 width=12) + Filter Operator [FIL_220] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 4) and d_date_sk is not null) Please refer to the previous TableScan [TS_3] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_234] + SHUFFLE [RS_239] PartitionCols:_col0 - Select Operator [SEL_233] (rows=501694138 width=126) + Select Operator [SEL_238] (rows=501694138 width=126) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_232] (rows=501694138 width=126) + Filter Operator [FIL_237] (rows=501694138 width=126) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_ticket_number is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_36_d1_d_date_sk_min) AND DynamicValue(RS_36_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_36_d1_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=126) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_net_profit"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_231] - Group By Operator [GBY_230] (rows=1 width=12) + BROADCAST [RS_236] + Group By Operator [GBY_235] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_228] - Group By Operator [GBY_226] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_233] + Group By Operator [GBY_231] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_222] (rows=50 width=4) + Select Operator [SEL_227] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_218] + Please refer to the previous Select Operator [SEL_223] diff --git ql/src/test/results/clientpositive/perf/tez/query26.q.out ql/src/test/results/clientpositive/perf/tez/query26.q.out index a1bf3b099b..baf533f2c7 100644 --- ql/src/test/results/clientpositive/perf/tez/query26.q.out +++ ql/src/test/results/clientpositive/perf/tez/query26.q.out @@ -67,95 +67,95 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_125] - Limit [LIM_124] (rows=100 width=444) + File Output Operator [FS_130] + Limit [LIM_129] (rows=100 width=444) Number of rows:100 - Select Operator [SEL_123] (rows=310774 width=444) + Select Operator [SEL_128] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_122] - Select Operator [SEL_121] (rows=310774 width=444) + SHUFFLE [RS_127] + Select Operator [SEL_126] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_120] (rows=310774 width=476) + Group By Operator [GBY_125] (rows=310774 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)"],keys:KEY._col0 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 Group By Operator [GBY_28] (rows=462000 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col4)","count(_col4)","sum(_col5)","count(_col5)","sum(_col7)","count(_col7)","sum(_col6)","count(_col6)"],keys:_col12 - Top N Key Operator [TNK_55] (rows=2317924 width=231) + Top N Key Operator [TNK_58] (rows=2317924 width=231) keys:_col12,top n:100 - Merge Join Operator [MERGEJOIN_99] (rows=2317924 width=231) - Conds:RS_24._col2=RS_119._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] + Merge Join Operator [MERGEJOIN_104] (rows=2317924 width=231) + Conds:RS_24._col2=RS_124._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_119] + SHUFFLE [RS_124] PartitionCols:_col0 - Select Operator [SEL_118] (rows=462000 width=104) + Select Operator [SEL_123] (rows=462000 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_117] (rows=462000 width=104) + Filter Operator [FIL_122] (rows=462000 width=104) predicate:i_item_sk is not null TableScan [TS_12] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_98] (rows=2317924 width=135) - Conds:RS_21._col3=RS_116._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_103] (rows=2317924 width=135) + Conds:RS_21._col3=RS_121._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_116] + SHUFFLE [RS_121] PartitionCols:_col0 - Select Operator [SEL_115] (rows=2300 width=4) + Select Operator [SEL_120] (rows=2300 width=4) Output:["_col0"] - Filter Operator [FIL_114] (rows=2300 width=174) + Filter Operator [FIL_119] (rows=2300 width=174) predicate:(((p_channel_email = 'N') or (p_channel_event = 'N')) and p_promo_sk is not null) TableScan [TS_9] (rows=2300 width=174) default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_email","p_channel_event"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_97] (rows=2317924 width=137) - Conds:RS_18._col0=RS_113._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_102] (rows=2317924 width=137) + Conds:RS_18._col0=RS_118._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6","_col7"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_113] + SHUFFLE [RS_118] PartitionCols:_col0 - Select Operator [SEL_112] (rows=652 width=4) + Select Operator [SEL_117] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_111] (rows=652 width=8) + Filter Operator [FIL_116] (rows=652 width=8) predicate:((d_year = 1998) and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_96] (rows=2317924 width=139) - Conds:RS_110._col1=RS_102._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_101] (rows=2317924 width=139) + Conds:RS_115._col1=RS_107._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_102] + PARTITION_ONLY_SHUFFLE [RS_107] PartitionCols:_col0 - Select Operator [SEL_101] (rows=14776 width=4) + Select Operator [SEL_106] (rows=14776 width=4) Output:["_col0"] - Filter Operator [FIL_100] (rows=14776 width=268) + Filter Operator [FIL_105] (rows=14776 width=268) predicate:((cd_marital_status = 'W') and (cd_education_status = 'Primary') and (cd_gender = 'F') and cd_demo_sk is not null) TableScan [TS_3] (rows=1861800 width=268) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_110] + SHUFFLE [RS_115] PartitionCols:_col1 - Select Operator [SEL_109] (rows=283691050 width=354) + Select Operator [SEL_114] (rows=283691050 width=354) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_108] (rows=283691050 width=354) + Filter Operator [FIL_113] (rows=283691050 width=354) predicate:(cs_promo_sk is not null and cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_item_sk is not null and cs_bill_cdemo_sk BETWEEN DynamicValue(RS_16_customer_demographics_cd_demo_sk_min) AND DynamicValue(RS_16_customer_demographics_cd_demo_sk_max) and in_bloom_filter(cs_bill_cdemo_sk, DynamicValue(RS_16_customer_demographics_cd_demo_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=354) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_cdemo_sk","cs_item_sk","cs_promo_sk","cs_quantity","cs_list_price","cs_sales_price","cs_coupon_amt"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_107] - Group By Operator [GBY_106] (rows=1 width=12) + BROADCAST [RS_112] + Group By Operator [GBY_111] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_105] - Group By Operator [GBY_104] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_110] + Group By Operator [GBY_109] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_103] (rows=14776 width=4) + Select Operator [SEL_108] (rows=14776 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_101] + Please refer to the previous Select Operator [SEL_106] diff --git ql/src/test/results/clientpositive/perf/tez/query27.q.out ql/src/test/results/clientpositive/perf/tez/query27.q.out index 6f49de2344..774c0fd192 100644 --- ql/src/test/results/clientpositive/perf/tez/query27.q.out +++ ql/src/test/results/clientpositive/perf/tez/query27.q.out @@ -71,97 +71,97 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_126] - Limit [LIM_125] (rows=100 width=538) + File Output Operator [FS_128] + Limit [LIM_127] (rows=100 width=538) Number of rows:100 - Select Operator [SEL_124] (rows=6526254 width=538) + Select Operator [SEL_126] (rows=6526254 width=538) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_123] - Select Operator [SEL_122] (rows=6526254 width=538) + SHUFFLE [RS_125] + Select Operator [SEL_124] (rows=6526254 width=538) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Group By Operator [GBY_121] (rows=6526254 width=570) + Group By Operator [GBY_123] (rows=6526254 width=570) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_29] (rows=13907934 width=570) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(_col2)","count(_col2)","sum(_col3)","count(_col3)","sum(_col4)","count(_col4)","sum(_col5)","count(_col5)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_56] (rows=4635978 width=186) - keys:_col0, _col1, 0L,top n:100 + Top N Key Operator [TNK_58] (rows=13907934 width=570) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_29] (rows=13907934 width=570) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"],aggregations:["sum(_col2)","count(_col2)","sum(_col3)","count(_col3)","sum(_col4)","count(_col4)","sum(_col5)","count(_col5)"],keys:_col0, _col1, 0L Select Operator [SEL_27] (rows=4635978 width=186) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_100] (rows=4635978 width=186) - Conds:RS_24._col1=RS_120._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col11","_col13"] + Merge Join Operator [MERGEJOIN_102] (rows=4635978 width=186) + Conds:RS_24._col1=RS_122._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col11","_col13"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_120] + SHUFFLE [RS_122] PartitionCols:_col0 - Select Operator [SEL_119] (rows=462000 width=104) + Select Operator [SEL_121] (rows=462000 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_118] (rows=462000 width=104) + Filter Operator [FIL_120] (rows=462000 width=104) predicate:i_item_sk is not null TableScan [TS_12] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_99] (rows=4635978 width=90) - Conds:RS_21._col3=RS_117._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col11"] + Merge Join Operator [MERGEJOIN_101] (rows=4635978 width=90) + Conds:RS_21._col3=RS_119._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col11"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] + SHUFFLE [RS_119] PartitionCols:_col0 - Select Operator [SEL_116] (rows=209 width=90) + Select Operator [SEL_118] (rows=209 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_115] (rows=209 width=90) + Filter Operator [FIL_117] (rows=209 width=90) predicate:((s_state) IN ('SD', 'FL', 'MI', 'LA', 'MO', 'SC') and s_store_sk is not null) TableScan [TS_9] (rows=1704 width=90) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_98] (rows=4635978 width=4) - Conds:RS_18._col0=RS_114._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_100] (rows=4635978 width=4) + Conds:RS_18._col0=RS_116._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_114] + SHUFFLE [RS_116] PartitionCols:_col0 - Select Operator [SEL_113] (rows=652 width=4) + Select Operator [SEL_115] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_112] (rows=652 width=8) + Filter Operator [FIL_114] (rows=652 width=8) predicate:((d_year = 2001) and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_97] (rows=4635978 width=4) - Conds:RS_111._col2=RS_103._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_99] (rows=4635978 width=4) + Conds:RS_113._col2=RS_105._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_103] + PARTITION_ONLY_SHUFFLE [RS_105] PartitionCols:_col0 - Select Operator [SEL_102] (rows=14776 width=4) + Select Operator [SEL_104] (rows=14776 width=4) Output:["_col0"] - Filter Operator [FIL_101] (rows=14776 width=268) + Filter Operator [FIL_103] (rows=14776 width=268) predicate:((cd_marital_status = 'U') and (cd_education_status = '2 yr Degree') and (cd_gender = 'M') and cd_demo_sk is not null) TableScan [TS_3] (rows=1861800 width=268) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_111] + SHUFFLE [RS_113] PartitionCols:_col2 - Select Operator [SEL_110] (rows=501690006 width=340) + Select Operator [SEL_112] (rows=501690006 width=340) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_109] (rows=501690006 width=340) + Filter Operator [FIL_111] (rows=501690006 width=340) predicate:(ss_cdemo_sk is not null and ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_cdemo_sk BETWEEN DynamicValue(RS_16_customer_demographics_cd_demo_sk_min) AND DynamicValue(RS_16_customer_demographics_cd_demo_sk_max) and in_bloom_filter(ss_cdemo_sk, DynamicValue(RS_16_customer_demographics_cd_demo_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=340) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_cdemo_sk","ss_store_sk","ss_quantity","ss_list_price","ss_sales_price","ss_coupon_amt"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_108] - Group By Operator [GBY_107] (rows=1 width=12) + BROADCAST [RS_110] + Group By Operator [GBY_109] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_106] - Group By Operator [GBY_105] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_108] + Group By Operator [GBY_107] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_104] (rows=14776 width=4) + Select Operator [SEL_106] (rows=14776 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_102] + Please refer to the previous Select Operator [SEL_104] diff --git ql/src/test/results/clientpositive/perf/tez/query29.q.out ql/src/test/results/clientpositive/perf/tez/query29.q.out index 5066893829..6be8366385 100644 --- ql/src/test/results/clientpositive/perf/tez/query29.q.out +++ ql/src/test/results/clientpositive/perf/tez/query29.q.out @@ -126,147 +126,147 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_244] - Limit [LIM_243] (rows=100 width=496) + File Output Operator [FS_249] + Limit [LIM_248] (rows=100 width=496) Number of rows:100 - Select Operator [SEL_242] (rows=478292911 width=496) + Select Operator [SEL_247] (rows=478292911 width=496) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_241] - Group By Operator [GBY_240] (rows=478292911 width=496) + SHUFFLE [RS_246] + Group By Operator [GBY_245] (rows=478292911 width=496) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_49] PartitionCols:_col0, _col1, _col2, _col3 Group By Operator [GBY_48] (rows=478292911 width=496) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col13)","sum(_col19)","sum(_col3)"],keys:_col6, _col7, _col22, _col23 - Top N Key Operator [TNK_93] (rows=97302218301 width=483) + Top N Key Operator [TNK_96] (rows=97302218301 width=483) keys:_col6, _col7, _col22, _col23,top n:100 - Merge Join Operator [MERGEJOIN_205] (rows=97302218301 width=483) + Merge Join Operator [MERGEJOIN_210] (rows=97302218301 width=483) Conds:RS_44._col2, _col1=RS_45._col11, _col12(Inner),Output:["_col3","_col6","_col7","_col13","_col19","_col22","_col23"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_45] PartitionCols:_col11, _col12 Select Operator [SEL_40] (rows=478292911 width=487) Output:["_col1","_col2","_col8","_col11","_col12","_col14","_col17","_col18"] - Merge Join Operator [MERGEJOIN_204] (rows=478292911 width=487) - Conds:RS_37._col3=RS_239._col0(Inner),Output:["_col5","_col8","_col9","_col11","_col14","_col15","_col17","_col18"] + Merge Join Operator [MERGEJOIN_209] (rows=478292911 width=487) + Conds:RS_37._col3=RS_244._col0(Inner),Output:["_col5","_col8","_col9","_col11","_col14","_col15","_col17","_col18"] <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] + SHUFFLE [RS_244] PartitionCols:_col0 - Select Operator [SEL_238] (rows=1704 width=192) + Select Operator [SEL_243] (rows=1704 width=192) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_237] (rows=1704 width=192) + Filter Operator [FIL_242] (rows=1704 width=192) predicate:s_store_sk is not null TableScan [TS_25] (rows=1704 width=192) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_37] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_203] (rows=478292911 width=303) - Conds:RS_34._col1=RS_236._col0(Inner),Output:["_col3","_col5","_col8","_col9","_col11","_col14","_col15"] + Merge Join Operator [MERGEJOIN_208] (rows=478292911 width=303) + Conds:RS_34._col1=RS_241._col0(Inner),Output:["_col3","_col5","_col8","_col9","_col11","_col14","_col15"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_236] + SHUFFLE [RS_241] PartitionCols:_col0 - Select Operator [SEL_235] (rows=462000 width=288) + Select Operator [SEL_240] (rows=462000 width=288) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_234] (rows=462000 width=288) + Filter Operator [FIL_239] (rows=462000 width=288) predicate:i_item_sk is not null TableScan [TS_22] (rows=462000 width=288) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_34] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_202] (rows=478292911 width=23) + Merge Join Operator [MERGEJOIN_207] (rows=478292911 width=23) Conds:RS_31._col1, _col2, _col4=RS_32._col1, _col2, _col3(Inner),Output:["_col1","_col3","_col5","_col8","_col9","_col11"] <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_32] PartitionCols:_col1, _col2, _col3 - Merge Join Operator [MERGEJOIN_201] (rows=53632139 width=15) - Conds:RS_233._col0=RS_223._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_206] (rows=53632139 width=15) + Conds:RS_238._col0=RS_228._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] + SHUFFLE [RS_228] PartitionCols:_col0 - Select Operator [SEL_220] (rows=201 width=4) + Select Operator [SEL_225] (rows=201 width=4) Output:["_col0"] - Filter Operator [FIL_218] (rows=201 width=12) + Filter Operator [FIL_223] (rows=201 width=12) predicate:((d_year = 1999) and d_moy BETWEEN 4 AND 7 and d_date_sk is not null) TableScan [TS_9] (rows=73049 width=12) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_233] + SHUFFLE [RS_238] PartitionCols:_col0 - Select Operator [SEL_232] (rows=53632139 width=19) + Select Operator [SEL_237] (rows=53632139 width=19) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_231] (rows=53632139 width=19) + Filter Operator [FIL_236] (rows=53632139 width=19) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null and sr_item_sk is not null and sr_ticket_number is not null) TableScan [TS_12] (rows=57591150 width=19) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number","sr_return_quantity"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_31] PartitionCols:_col1, _col2, _col4 - Merge Join Operator [MERGEJOIN_200] (rows=501694138 width=19) - Conds:RS_230._col0=RS_221._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_205] (rows=501694138 width=19) + Conds:RS_235._col0=RS_226._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5"] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_221] + SHUFFLE [RS_226] PartitionCols:_col0 - Select Operator [SEL_219] (rows=50 width=4) + Select Operator [SEL_224] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_217] (rows=50 width=12) + Filter Operator [FIL_222] (rows=50 width=12) predicate:((d_year = 1999) and (d_moy = 4) and d_date_sk is not null) Please refer to the previous TableScan [TS_9] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_230] + SHUFFLE [RS_235] PartitionCols:_col0 - Select Operator [SEL_229] (rows=501694138 width=23) + Select Operator [SEL_234] (rows=501694138 width=23) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_228] (rows=501694138 width=23) + Filter Operator [FIL_233] (rows=501694138 width=23) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_ticket_number is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_29_d1_d_date_sk_min) AND DynamicValue(RS_29_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_29_d1_d_date_sk_bloom_filter))) TableScan [TS_6] (rows=575995635 width=23) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number","ss_quantity"] <-Reducer 14 [BROADCAST_EDGE] vectorized - BROADCAST [RS_227] - Group By Operator [GBY_226] (rows=1 width=12) + BROADCAST [RS_232] + Group By Operator [GBY_231] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 13 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] - Group By Operator [GBY_224] (rows=1 width=12) + SHUFFLE [RS_230] + Group By Operator [GBY_229] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_222] (rows=50 width=4) + Select Operator [SEL_227] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_219] + Please refer to the previous Select Operator [SEL_224] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col2, _col1 - Merge Join Operator [MERGEJOIN_199] (rows=285117831 width=11) - Conds:RS_216._col0=RS_208._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_204] (rows=285117831 width=11) + Conds:RS_221._col0=RS_213._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_208] + PARTITION_ONLY_SHUFFLE [RS_213] PartitionCols:_col0 - Select Operator [SEL_207] (rows=1957 width=4) + Select Operator [SEL_212] (rows=1957 width=4) Output:["_col0"] - Filter Operator [FIL_206] (rows=1957 width=8) + Filter Operator [FIL_211] (rows=1957 width=8) predicate:((d_year) IN (1999, 2000, 2001) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=8) default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_216] + SHUFFLE [RS_221] PartitionCols:_col0 - Select Operator [SEL_215] (rows=285117831 width=15) + Select Operator [SEL_220] (rows=285117831 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_214] (rows=285117831 width=15) + Filter Operator [FIL_219] (rows=285117831 width=15) predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_42_d3_d_date_sk_min) AND DynamicValue(RS_42_d3_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_42_d3_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=15) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_quantity"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_213] - Group By Operator [GBY_212] (rows=1 width=12) + BROADCAST [RS_218] + Group By Operator [GBY_217] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_211] - Group By Operator [GBY_210] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_216] + Group By Operator [GBY_215] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_209] (rows=1957 width=4) + Select Operator [SEL_214] (rows=1957 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_207] + Please refer to the previous Select Operator [SEL_212] diff --git ql/src/test/results/clientpositive/perf/tez/query3.q.out ql/src/test/results/clientpositive/perf/tez/query3.q.out index fe97d402c4..d79b0f1542 100644 --- ql/src/test/results/clientpositive/perf/tez/query3.q.out +++ ql/src/test/results/clientpositive/perf/tez/query3.q.out @@ -61,63 +61,67 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_72] - Limit [LIM_71] (rows=100 width=220) + File Output Operator [FS_76] + Limit [LIM_75] (rows=100 width=220) Number of rows:100 - Select Operator [SEL_70] (rows=7666836 width=219) + Select Operator [SEL_74] (rows=7666836 width=219) Output:["_col0","_col1","_col2","_col3"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - Group By Operator [GBY_68] (rows=7666836 width=219) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_16] (rows=7666836 width=219) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col7, _col4, _col5 - Merge Join Operator [MERGEJOIN_53] (rows=7666836 width=108) - Conds:RS_12._col0=RS_67._col0(Inner),Output:["_col2","_col4","_col5","_col7"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_67] - PartitionCols:_col0 - Select Operator [SEL_66] (rows=5619 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_65] (rows=5619 width=12) - predicate:((d_moy = 12) and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_52] (rows=7666836 width=104) - Conds:RS_64._col1=RS_56._col0(Inner),Output:["_col0","_col2","_col4","_col5"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_56] + SHUFFLE [RS_73] + Top N Key Operator [TNK_72] (rows=7666836 width=219) + keys:_col0, _col3, _col1,top n:100 + Group By Operator [GBY_71] (rows=7666836 width=219) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + Top N Key Operator [TNK_70] (rows=7666836 width=219) + keys:KEY._col0,top n:100 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_16] (rows=7666836 width=219) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col7, _col4, _col5 + Merge Join Operator [MERGEJOIN_55] (rows=7666836 width=108) + Conds:RS_12._col0=RS_69._col0(Inner),Output:["_col2","_col4","_col5","_col7"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] PartitionCols:_col0 - Select Operator [SEL_55] (rows=669 width=107) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_54] (rows=669 width=111) - predicate:((i_manufact_id = 436) and i_item_sk is not null) - TableScan [TS_3] (rows=462000 width=111) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_64] - PartitionCols:_col1 - Select Operator [SEL_63] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_62] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_61] - Group By Operator [GBY_60] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_59] - Group By Operator [GBY_58] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_57] (rows=669 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_55] + Select Operator [SEL_68] (rows=5619 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_67] (rows=5619 width=12) + predicate:((d_moy = 12) and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_54] (rows=7666836 width=104) + Conds:RS_66._col1=RS_58._col0(Inner),Output:["_col0","_col2","_col4","_col5"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=669 width=107) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_56] (rows=669 width=111) + predicate:((i_manufact_id = 436) and i_item_sk is not null) + TableScan [TS_3] (rows=462000 width=111) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manufact_id"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col1 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_10_item_i_item_sk_min) AND DynamicValue(RS_10_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_10_item_i_item_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=669 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/query30.q.out ql/src/test/results/clientpositive/perf/tez/query30.q.out index ac683c2515..6e46087fca 100644 --- ql/src/test/results/clientpositive/perf/tez/query30.q.out +++ ql/src/test/results/clientpositive/perf/tez/query30.q.out @@ -87,139 +87,141 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_215] - Limit [LIM_214] (rows=100 width=949) + File Output Operator [FS_216] + Limit [LIM_215] (rows=100 width=945) Number of rows:100 - Select Operator [SEL_213] (rows=4179738 width=949) + Select Operator [SEL_214] (rows=4179738 width=944) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_66] - Select Operator [SEL_65] (rows=4179738 width=949) + Select Operator [SEL_65] (rows=4179738 width=944) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - Merge Join Operator [MERGEJOIN_180] (rows=4179738 width=949) - Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col17"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_62] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_174] (rows=1568628 width=834) - Conds:RS_183._col2=RS_190._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_190] - PartitionCols:_col0 - Select Operator [SEL_187] (rows=784314 width=4) - Output:["_col0"] - Filter Operator [FIL_184] (rows=784314 width=90) - predicate:((ca_state = 'IL') and ca_address_sk is not null) - TableScan [TS_3] (rows=40000000 width=90) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_183] - PartitionCols:_col2 - Select Operator [SEL_182] (rows=80000000 width=849) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] - Filter Operator [FIL_181] (rows=80000000 width=849) - predicate:(c_current_addr_sk is not null and c_customer_sk is not null) - TableScan [TS_0] (rows=80000000 width=849) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_day","c_birth_month","c_birth_year","c_birth_country","c_login","c_email_address","c_last_review_date"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Select Operator [SEL_58] (rows=4179738 width=227) - Output:["_col0","_col2"] - Filter Operator [FIL_57] (rows=4179738 width=227) - predicate:(_col2 > _col3) - Merge Join Operator [MERGEJOIN_179] (rows=12539214 width=227) - Conds:RS_206._col1=RS_212._col1(Inner),Output:["_col0","_col2","_col3"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_212] - PartitionCols:_col1 - Select Operator [SEL_211] (rows=17 width=198) - Output:["_col0","_col1"] - Filter Operator [FIL_210] (rows=17 width=206) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_209] (rows=17 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 - Select Operator [SEL_208] (rows=13130761 width=201) - Output:["_col0","_col2"] - Group By Operator [GBY_207] (rows=13130761 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col0 - Group By Operator [GBY_44] (rows=13130761 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_178] (rows=13130761 width=196) - Conds:RS_40._col2=RS_192._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_192] - PartitionCols:_col0 - Select Operator [SEL_189] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_186] (rows=40000000 width=90) - predicate:(ca_address_sk is not null and ca_state is not null) - Please refer to the previous TableScan [TS_3] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_177] (rows=13130761 width=114) - Conds:RS_198._col0=RS_202._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] - PartitionCols:_col0 - Select Operator [SEL_196] (rows=13130761 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_194] (rows=13130761 width=118) - predicate:(wr_returned_date_sk is not null and wr_returning_addr_sk is not null) - TableScan [TS_6] (rows=14398467 width=118) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_returning_customer_sk","wr_returning_addr_sk","wr_return_amt"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_202] - PartitionCols:_col0 - Select Operator [SEL_200] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_199] (rows=652 width=8) - predicate:((d_year = 2002) and d_date_sk is not null) - TableScan [TS_9] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_206] - PartitionCols:_col1 - Filter Operator [FIL_205] (rows=12539214 width=201) - predicate:_col2 is not null - Select Operator [SEL_204] (rows=12539214 width=201) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_203] (rows=12539214 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=12539214 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_176] (rows=12539214 width=196) - Conds:RS_18._col2=RS_191._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] + Top N Key Operator [TNK_104] (rows=4179738 width=949) + keys:_col1, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col17,top n:100 + Merge Join Operator [MERGEJOIN_181] (rows=4179738 width=949) + Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col17"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_62] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_175] (rows=1568628 width=834) + Conds:RS_184._col2=RS_191._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_191] + PartitionCols:_col0 + Select Operator [SEL_188] (rows=784314 width=4) + Output:["_col0"] + Filter Operator [FIL_185] (rows=784314 width=90) + predicate:((ca_state = 'IL') and ca_address_sk is not null) + TableScan [TS_3] (rows=40000000 width=90) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_184] + PartitionCols:_col2 + Select Operator [SEL_183] (rows=80000000 width=849) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13"] + Filter Operator [FIL_182] (rows=80000000 width=849) + predicate:(c_current_addr_sk is not null and c_customer_sk is not null) + TableScan [TS_0] (rows=80000000 width=849) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_day","c_birth_month","c_birth_year","c_birth_country","c_login","c_email_address","c_last_review_date"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_58] (rows=4179738 width=227) + Output:["_col0","_col2"] + Filter Operator [FIL_57] (rows=4179738 width=227) + predicate:(_col2 > _col3) + Merge Join Operator [MERGEJOIN_180] (rows=12539214 width=227) + Conds:RS_207._col1=RS_213._col1(Inner),Output:["_col0","_col2","_col3"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_213] + PartitionCols:_col1 + Select Operator [SEL_212] (rows=17 width=198) + Output:["_col0","_col1"] + Filter Operator [FIL_211] (rows=17 width=206) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_210] (rows=17 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 + Select Operator [SEL_209] (rows=13130761 width=201) + Output:["_col0","_col2"] + Group By Operator [GBY_208] (rows=13130761 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_45] PartitionCols:_col0 - Select Operator [SEL_188] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_185] (rows=40000000 width=90) - predicate:(ca_address_sk is not null and ca_state is not null) - Please refer to the previous TableScan [TS_3] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_175] (rows=12539214 width=114) - Conds:RS_197._col0=RS_201._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_197] - PartitionCols:_col0 - Select Operator [SEL_195] (rows=12539214 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_193] (rows=12539214 width=118) - predicate:(wr_returning_customer_sk is not null and wr_returned_date_sk is not null and wr_returning_addr_sk is not null) - Please refer to the previous TableScan [TS_6] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_200] + Group By Operator [GBY_44] (rows=13130761 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_179] (rows=13130761 width=196) + Conds:RS_40._col2=RS_193._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_193] + PartitionCols:_col0 + Select Operator [SEL_190] (rows=40000000 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_187] (rows=40000000 width=90) + predicate:(ca_address_sk is not null and ca_state is not null) + Please refer to the previous TableScan [TS_3] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_178] (rows=13130761 width=114) + Conds:RS_199._col0=RS_203._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_199] + PartitionCols:_col0 + Select Operator [SEL_197] (rows=13130761 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_195] (rows=13130761 width=118) + predicate:(wr_returned_date_sk is not null and wr_returning_addr_sk is not null) + TableScan [TS_6] (rows=14398467 width=118) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_returning_customer_sk","wr_returning_addr_sk","wr_return_amt"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_203] + PartitionCols:_col0 + Select Operator [SEL_201] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_200] (rows=652 width=8) + predicate:((d_year = 2002) and d_date_sk is not null) + TableScan [TS_9] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Reducer 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_207] + PartitionCols:_col1 + Filter Operator [FIL_206] (rows=12539214 width=201) + predicate:_col2 is not null + Select Operator [SEL_205] (rows=12539214 width=201) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_204] (rows=12539214 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1 + Group By Operator [GBY_22] (rows=12539214 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_177] (rows=12539214 width=196) + Conds:RS_18._col2=RS_192._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_192] + PartitionCols:_col0 + Select Operator [SEL_189] (rows=40000000 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_186] (rows=40000000 width=90) + predicate:(ca_address_sk is not null and ca_state is not null) + Please refer to the previous TableScan [TS_3] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_176] (rows=12539214 width=114) + Conds:RS_198._col0=RS_202._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_198] + PartitionCols:_col0 + Select Operator [SEL_196] (rows=12539214 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_194] (rows=12539214 width=118) + predicate:(wr_returning_customer_sk is not null and wr_returned_date_sk is not null and wr_returning_addr_sk is not null) + Please refer to the previous TableScan [TS_6] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_202] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_201] diff --git ql/src/test/results/clientpositive/perf/tez/query33.q.out ql/src/test/results/clientpositive/perf/tez/query33.q.out index dc4f6b17c1..36846dfe1d 100644 --- ql/src/test/results/clientpositive/perf/tez/query33.q.out +++ ql/src/test/results/clientpositive/perf/tez/query33.q.out @@ -191,224 +191,226 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_357] - Limit [LIM_356] (rows=7 width=116) + File Output Operator [FS_359] + Limit [LIM_358] (rows=7 width=116) Number of rows:100 - Select Operator [SEL_355] (rows=7 width=116) + Select Operator [SEL_357] (rows=7 width=116) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_354] - Group By Operator [GBY_353] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 11 [CONTAINS] vectorized - Reduce Output Operator [RS_373] - PartitionCols:_col0 - Group By Operator [GBY_372] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_371] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_109] - PartitionCols:_col0 - Group By Operator [GBY_108] (rows=8 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_304] (rows=206906 width=96) - Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_104] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_293] (rows=46084 width=7) - Conds:RS_319._col1=RS_325._col0(Inner),Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col1 - Select Operator [SEL_318] (rows=460848 width=7) - Output:["_col0","_col1"] - Filter Operator [FIL_317] (rows=460848 width=7) - predicate:(i_manufact_id is not null and i_item_sk is not null) - TableScan [TS_0] (rows=462000 width=7) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_manufact_id"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_325] - PartitionCols:_col0 - Group By Operator [GBY_324] (rows=69 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Group By Operator [GBY_322] (rows=70 width=4) - Output:["_col0"],keys:i_manufact_id - Select Operator [SEL_321] (rows=46085 width=93) - Output:["i_manufact_id"] - Filter Operator [FIL_320] (rows=46085 width=93) - predicate:((i_category = 'Books') and i_manufact_id is not null) - TableScan [TS_3] (rows=462000 width=93) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_category","i_manufact_id"] - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_105] - PartitionCols:_col2 - Select Operator [SEL_100] (rows=143931246 width=115) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=115) - Conds:RS_97._col2=RS_349._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_349] - PartitionCols:_col0 - Select Operator [SEL_346] (rows=8000000 width=4) - Output:["_col0"] - Filter Operator [FIL_345] (rows=8000000 width=112) - predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) - TableScan [TS_16] (rows=40000000 width=112) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_300] (rows=143931246 width=119) - Conds:RS_370._col0=RS_332._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_332] - PartitionCols:_col0 - Select Operator [SEL_327] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_326] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) - TableScan [TS_13] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_370] - PartitionCols:_col0 - Select Operator [SEL_369] (rows=143931246 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_368] (rows=143931246 width=123) - predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_85] (rows=144002668 width=123) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_367] - Group By Operator [GBY_366] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_339] - Group By Operator [GBY_336] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_333] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 4 [CONTAINS] vectorized - Reduce Output Operator [RS_352] - PartitionCols:_col0 - Group By Operator [GBY_351] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_350] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col0 - Group By Operator [GBY_33] (rows=8 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_302] (rows=755172 width=3) - Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_293] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col2 - Select Operator [SEL_25] (rows=525327191 width=110) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=110) - Conds:RS_22._col2=RS_347._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_347] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_294] (rows=525327191 width=114) - Conds:RS_344._col0=RS_328._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_328] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] - PartitionCols:_col0 - Select Operator [SEL_343] (rows=525327191 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_342] (rows=525327191 width=118) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_10] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_341] - Group By Operator [GBY_340] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_337] - Group By Operator [GBY_334] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_329] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_365] - PartitionCols:_col0 - Group By Operator [GBY_364] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_363] (rows=7 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_71] - PartitionCols:_col0 - Group By Operator [GBY_70] (rows=8 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_303] (rows=409865 width=3) - Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_293] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_67] - PartitionCols:_col3 - Select Operator [SEL_62] (rows=285117733 width=115) - Output:["_col3","_col4"] - Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=115) - Conds:RS_59._col1=RS_348._col0(Inner),Output:["_col2","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_59] + SHUFFLE [RS_356] + Top N Key Operator [TNK_355] (rows=7 width=116) + keys:_col1,top n:100 + Group By Operator [GBY_354] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 11 [CONTAINS] vectorized + Reduce Output Operator [RS_375] + PartitionCols:_col0 + Group By Operator [GBY_374] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_373] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_109] + PartitionCols:_col0 + Group By Operator [GBY_108] (rows=8 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_305] (rows=206906 width=96) + Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_104] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_294] (rows=46084 width=7) + Conds:RS_320._col1=RS_326._col0(Inner),Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_320] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_297] (rows=285117733 width=119) - Conds:RS_362._col0=RS_330._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_330] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_362] + Select Operator [SEL_319] (rows=460848 width=7) + Output:["_col0","_col1"] + Filter Operator [FIL_318] (rows=460848 width=7) + predicate:(i_manufact_id is not null and i_item_sk is not null) + TableScan [TS_0] (rows=462000 width=7) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_manufact_id"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_326] + PartitionCols:_col0 + Group By Operator [GBY_325] (rows=69 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_324] PartitionCols:_col0 - Select Operator [SEL_361] (rows=285117733 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_360] (rows=285117733 width=123) - predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_47] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_359] - Group By Operator [GBY_358] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_338] - Group By Operator [GBY_335] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_331] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] + Group By Operator [GBY_323] (rows=70 width=4) + Output:["_col0"],keys:i_manufact_id + Select Operator [SEL_322] (rows=46085 width=93) + Output:["i_manufact_id"] + Filter Operator [FIL_321] (rows=46085 width=93) + predicate:((i_category = 'Books') and i_manufact_id is not null) + TableScan [TS_3] (rows=462000 width=93) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_category","i_manufact_id"] + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_105] + PartitionCols:_col2 + Select Operator [SEL_100] (rows=143931246 width=115) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_302] (rows=143931246 width=115) + Conds:RS_97._col2=RS_350._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_350] + PartitionCols:_col0 + Select Operator [SEL_347] (rows=8000000 width=4) + Output:["_col0"] + Filter Operator [FIL_346] (rows=8000000 width=112) + predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) + TableScan [TS_16] (rows=40000000 width=112) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_97] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=119) + Conds:RS_372._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_333] + PartitionCols:_col0 + Select Operator [SEL_328] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_327] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) + TableScan [TS_13] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_372] + PartitionCols:_col0 + Select Operator [SEL_371] (rows=143931246 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_370] (rows=143931246 width=123) + predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_85] (rows=144002668 width=123) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_369] + Group By Operator [GBY_368] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_340] + Group By Operator [GBY_337] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_334] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] + <-Reducer 4 [CONTAINS] vectorized + Reduce Output Operator [RS_353] + PartitionCols:_col0 + Group By Operator [GBY_352] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_351] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col0 + Group By Operator [GBY_33] (rows=8 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_303] (rows=755172 width=3) + Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_294] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col2 + Select Operator [SEL_25] (rows=525327191 width=110) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_296] (rows=525327191 width=110) + Conds:RS_22._col2=RS_348._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_348] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_347] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=114) + Conds:RS_345._col0=RS_329._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_329] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_328] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_345] + PartitionCols:_col0 + Select Operator [SEL_344] (rows=525327191 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_343] (rows=525327191 width=118) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_10] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_342] + Group By Operator [GBY_341] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_338] + Group By Operator [GBY_335] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_330] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] + <-Reducer 9 [CONTAINS] vectorized + Reduce Output Operator [RS_367] + PartitionCols:_col0 + Group By Operator [GBY_366] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_365] (rows=7 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_71] + PartitionCols:_col0 + Group By Operator [GBY_70] (rows=8 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_304] (rows=409865 width=3) + Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_294] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_67] + PartitionCols:_col3 + Select Operator [SEL_62] (rows=285117733 width=115) + Output:["_col3","_col4"] + Merge Join Operator [MERGEJOIN_299] (rows=285117733 width=115) + Conds:RS_59._col1=RS_349._col0(Inner),Output:["_col2","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_347] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_59] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=119) + Conds:RS_364._col0=RS_331._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_331] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_328] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_364] + PartitionCols:_col0 + Select Operator [SEL_363] (rows=285117733 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_362] (rows=285117733 width=123) + predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_47] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 21 [BROADCAST_EDGE] vectorized + BROADCAST [RS_361] + Group By Operator [GBY_360] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_339] + Group By Operator [GBY_336] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_332] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] diff --git ql/src/test/results/clientpositive/perf/tez/query35.q.out ql/src/test/results/clientpositive/perf/tez/query35.q.out index 265c51bb72..74e539fd90 100644 --- ql/src/test/results/clientpositive/perf/tez/query35.q.out +++ ql/src/test/results/clientpositive/perf/tez/query35.q.out @@ -153,82 +153,82 @@ Stage-0 limit:-1 Stage-1 Reducer 8 vectorized - File Output Operator [FS_229] - Limit [LIM_228] (rows=1 width=352) + File Output Operator [FS_234] + Limit [LIM_233] (rows=1 width=352) Number of rows:100 - Select Operator [SEL_227] (rows=1 width=352) + Select Operator [SEL_232] (rows=1 width=352) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_226] - Select Operator [SEL_225] (rows=1 width=352) + SHUFFLE [RS_231] + Select Operator [SEL_230] (rows=1 width=352) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col12","_col14","_col15","_col16","_col17"] - Group By Operator [GBY_224] (rows=1 width=336) + Group By Operator [GBY_229] (rows=1 width=336) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)","count(VALUE._col2)","max(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","max(VALUE._col6)","sum(VALUE._col7)","count(VALUE._col8)","max(VALUE._col9)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_67] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 Group By Operator [GBY_66] (rows=2 width=336) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15"],aggregations:["count()","sum(_col8)","count(_col8)","max(_col8)","sum(_col9)","count(_col9)","max(_col9)","sum(_col10)","count(_col10)","max(_col10)"],keys:_col4, _col6, _col7, _col8, _col9, _col10 - Top N Key Operator [TNK_104] (rows=1401496 width=276) - keys:_col4, _col6, _col7, _col8, _col9, _col10,top n:100 - Select Operator [SEL_65] (rows=1401496 width=276) - Output:["_col4","_col6","_col7","_col8","_col9","_col10"] + Select Operator [SEL_65] (rows=1401496 width=276) + Output:["_col4","_col6","_col7","_col8","_col9","_col10"] + Top N Key Operator [TNK_107] (rows=1401496 width=276) + keys:_col4, _col6, _col7, _col8, _col9, _col10,top n:100 Filter Operator [FIL_64] (rows=1401496 width=276) predicate:(_col11 is not null or _col13 is not null) - Merge Join Operator [MERGEJOIN_182] (rows=1401496 width=276) - Conds:RS_61._col0=RS_223._col1(Left Outer),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col13"] + Merge Join Operator [MERGEJOIN_187] (rows=1401496 width=276) + Conds:RS_61._col0=RS_228._col1(Left Outer),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col13"] <-Reducer 5 [SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_61] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_181] (rows=1414922 width=276) - Conds:RS_58._col0=RS_215._col1(Left Outer),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10","_col11"] + Merge Join Operator [MERGEJOIN_186] (rows=1414922 width=276) + Conds:RS_58._col0=RS_220._col1(Left Outer),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10","_col11"] <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_215] + SHUFFLE [RS_220] PartitionCols:_col1 - Select Operator [SEL_214] (rows=1414922 width=7) + Select Operator [SEL_219] (rows=1414922 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_213] (rows=1414922 width=3) + Group By Operator [GBY_218] (rows=1414922 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0 Group By Operator [GBY_29] (rows=143930993 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=143930993 width=3) - Conds:RS_212._col0=RS_196._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_183] (rows=143930993 width=3) + Conds:RS_217._col0=RS_201._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_196] + SHUFFLE [RS_201] PartitionCols:_col0 - Select Operator [SEL_193] (rows=652 width=4) + Select Operator [SEL_198] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_192] (rows=652 width=12) + Filter Operator [FIL_197] (rows=652 width=12) predicate:((d_year = 1999) and (d_qoy < 4) and d_date_sk is not null) TableScan [TS_12] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_212] + SHUFFLE [RS_217] PartitionCols:_col0 - Select Operator [SEL_211] (rows=143930993 width=7) + Select Operator [SEL_216] (rows=143930993 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_210] (rows=143930993 width=7) + Filter Operator [FIL_215] (rows=143930993 width=7) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_26_date_dim_d_date_sk_min) AND DynamicValue(RS_26_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_26_date_dim_d_date_sk_bloom_filter))) TableScan [TS_19] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"] <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_209] - Group By Operator [GBY_208] (rows=1 width=12) + BROADCAST [RS_214] + Group By Operator [GBY_213] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_202] - Group By Operator [GBY_200] (rows=1 width=12) + SHUFFLE [RS_207] + Group By Operator [GBY_205] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_197] (rows=652 width=4) + Select Operator [SEL_202] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_58] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_180] (rows=525327388 width=272) + Merge Join Operator [MERGEJOIN_185] (rows=525327388 width=272) Conds:RS_55._col0=RS_56._col0(Left Semi),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_56] @@ -237,105 +237,105 @@ Stage-0 Output:["_col0"],keys:_col0 Select Operator [SEL_18] (rows=525327388 width=3) Output:["_col0"] - Merge Join Operator [MERGEJOIN_177] (rows=525327388 width=3) - Conds:RS_207._col0=RS_194._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_182] (rows=525327388 width=3) + Conds:RS_212._col0=RS_199._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_194] + SHUFFLE [RS_199] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_207] + SHUFFLE [RS_212] PartitionCols:_col0 - Select Operator [SEL_206] (rows=525327388 width=7) + Select Operator [SEL_211] (rows=525327388 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_205] (rows=525327388 width=7) + Filter Operator [FIL_210] (rows=525327388 width=7) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) TableScan [TS_9] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_204] - Group By Operator [GBY_203] (rows=1 width=12) + BROADCAST [RS_209] + Group By Operator [GBY_208] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - Group By Operator [GBY_199] (rows=1 width=12) + SHUFFLE [RS_206] + Group By Operator [GBY_204] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_195] (rows=652 width=4) + Select Operator [SEL_200] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_55] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_176] (rows=78293105 width=272) - Conds:RS_50._col1=RS_191._col0(Inner),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10"] + Merge Join Operator [MERGEJOIN_181] (rows=78293105 width=272) + Conds:RS_50._col1=RS_196._col0(Inner),Output:["_col0","_col4","_col6","_col7","_col8","_col9","_col10"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] + SHUFFLE [RS_196] PartitionCols:_col0 - Select Operator [SEL_190] (rows=1861800 width=186) + Select Operator [SEL_195] (rows=1861800 width=186) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_189] (rows=1861800 width=186) + Filter Operator [FIL_194] (rows=1861800 width=186) predicate:cd_demo_sk is not null TableScan [TS_6] (rows=1861800 width=186) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_dep_count","cd_dep_employed_count","cd_dep_college_count"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_50] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_175] (rows=77201384 width=93) - Conds:RS_185._col2=RS_188._col0(Inner),Output:["_col0","_col1","_col4"] + Merge Join Operator [MERGEJOIN_180] (rows=77201384 width=93) + Conds:RS_190._col2=RS_193._col0(Inner),Output:["_col0","_col1","_col4"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_185] + SHUFFLE [RS_190] PartitionCols:_col2 - Select Operator [SEL_184] (rows=77201384 width=11) + Select Operator [SEL_189] (rows=77201384 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_183] (rows=77201384 width=11) + Filter Operator [FIL_188] (rows=77201384 width=11) predicate:(c_current_cdemo_sk is not null and c_current_addr_sk is not null and c_customer_sk is not null) TableScan [TS_0] (rows=80000000 width=11) default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_188] + SHUFFLE [RS_193] PartitionCols:_col0 - Select Operator [SEL_187] (rows=40000000 width=90) + Select Operator [SEL_192] (rows=40000000 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_186] (rows=40000000 width=90) + Filter Operator [FIL_191] (rows=40000000 width=90) predicate:ca_address_sk is not null TableScan [TS_3] (rows=40000000 width=90) default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_223] + SHUFFLE [RS_228] PartitionCols:_col1 - Select Operator [SEL_222] (rows=1401496 width=7) + Select Operator [SEL_227] (rows=1401496 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_221] (rows=1401496 width=3) + Group By Operator [GBY_226] (rows=1401496 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col0 Group By Operator [GBY_43] (rows=285115246 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_179] (rows=285115246 width=3) - Conds:RS_220._col0=RS_198._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_184] (rows=285115246 width=3) + Conds:RS_225._col0=RS_203._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] + SHUFFLE [RS_203] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_193] + Please refer to the previous Select Operator [SEL_198] <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_220] + SHUFFLE [RS_225] PartitionCols:_col0 - Select Operator [SEL_219] (rows=285115246 width=7) + Select Operator [SEL_224] (rows=285115246 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_218] (rows=285115246 width=7) + Filter Operator [FIL_223] (rows=285115246 width=7) predicate:(cs_ship_customer_sk is not null and cs_sold_date_sk is not null and cs_ship_customer_sk BETWEEN DynamicValue(RS_61_c_c_customer_sk_min) AND DynamicValue(RS_61_c_c_customer_sk_max) and in_bloom_filter(cs_ship_customer_sk, DynamicValue(RS_61_c_c_customer_sk_bloom_filter))) TableScan [TS_33] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_217] - Group By Operator [GBY_216] (rows=1 width=12) + BROADCAST [RS_222] + Group By Operator [GBY_221] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Reducer 5 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_167] - Group By Operator [GBY_166] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_172] + Group By Operator [GBY_171] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_165] (rows=1414922 width=4) + Select Operator [SEL_170] (rows=1414922 width=4) Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_181] + Please refer to the previous Merge Join Operator [MERGEJOIN_186] diff --git ql/src/test/results/clientpositive/perf/tez/query36.q.out ql/src/test/results/clientpositive/perf/tez/query36.q.out index 544d883846..44aa1fc31c 100644 --- ql/src/test/results/clientpositive/perf/tez/query36.q.out +++ ql/src/test/results/clientpositive/perf/tez/query36.q.out @@ -83,90 +83,92 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_109] - Limit [LIM_108] (rows=100 width=490) + File Output Operator [FS_111] + Limit [LIM_110] (rows=100 width=490) Number of rows:100 - Select Operator [SEL_107] (rows=3060 width=490) + Select Operator [SEL_109] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_106] - Select Operator [SEL_105] (rows=3060 width=490) + SHUFFLE [RS_108] + Select Operator [SEL_107] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_104] (rows=3060 width=414) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(_col2 / _col3) ASC NULLS LAST","partition by:":"(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] - Select Operator [SEL_103] (rows=3060 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_102] - PartitionCols:(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END - Select Operator [SEL_101] (rows=3060 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_100] (rows=3060 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_23] (rows=2487780 width=414) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1, 0L - Select Operator [SEL_21] (rows=525329897 width=395) - Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_82] (rows=525329897 width=395) - Conds:RS_18._col1=RS_99._col0(Inner),Output:["_col3","_col4","_col8","_col9"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_99] - PartitionCols:_col0 - Select Operator [SEL_98] (rows=462000 width=186) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_97] (rows=462000 width=186) - predicate:i_item_sk is not null - TableScan [TS_9] (rows=462000 width=186) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=217) - Conds:RS_15._col2=RS_96._col0(Inner),Output:["_col1","_col3","_col4"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] - PartitionCols:_col0 - Select Operator [SEL_95] (rows=278 width=4) - Output:["_col0"] - Filter Operator [FIL_94] (rows=278 width=90) - predicate:((s_state) IN ('SD', 'FL', 'MI', 'LA', 'MO', 'SC', 'AL', 'GA') and s_store_sk is not null) - TableScan [TS_6] (rows=1704 width=90) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_80] (rows=525329897 width=221) - Conds:RS_93._col0=RS_85._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_85] - PartitionCols:_col0 - Select Operator [SEL_84] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_83] (rows=652 width=8) - predicate:((d_year = 1999) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_93] - PartitionCols:_col0 - Select Operator [SEL_92] (rows=525329897 width=225) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_91] (rows=525329897 width=225) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_13_d1_d_date_sk_min) AND DynamicValue(RS_13_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_13_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=225) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] - <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_90] - Group By Operator [GBY_89] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_88] - Group By Operator [GBY_87] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_86] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_84] + Top N Key Operator [TNK_106] (rows=3060 width=414) + keys:(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN (((grouping(_col4, 1L) + grouping(_col4, 0L)) = 0L)) THEN (_col0) ELSE (null) END, rank_window_0,top n:100 + PTF Operator [PTF_105] (rows=3060 width=414) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(_col2 / _col3) ASC NULLS LAST","partition by:":"(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] + Select Operator [SEL_104] (rows=3060 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_103] + PartitionCols:(grouping(_col4, 1L) + grouping(_col4, 0L)), CASE WHEN ((grouping(_col4, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END + Select Operator [SEL_102] (rows=3060 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"] + Group By Operator [GBY_101] (rows=3060 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_23] (rows=2487780 width=414) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1, 0L + Select Operator [SEL_21] (rows=525329897 width=395) + Output:["_col0","_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_83] (rows=525329897 width=395) + Conds:RS_18._col1=RS_100._col0(Inner),Output:["_col3","_col4","_col8","_col9"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_100] + PartitionCols:_col0 + Select Operator [SEL_99] (rows=462000 width=186) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_98] (rows=462000 width=186) + predicate:i_item_sk is not null + TableScan [TS_9] (rows=462000 width=186) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_82] (rows=525329897 width=217) + Conds:RS_15._col2=RS_97._col0(Inner),Output:["_col1","_col3","_col4"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_97] + PartitionCols:_col0 + Select Operator [SEL_96] (rows=278 width=4) + Output:["_col0"] + Filter Operator [FIL_95] (rows=278 width=90) + predicate:((s_state) IN ('SD', 'FL', 'MI', 'LA', 'MO', 'SC', 'AL', 'GA') and s_store_sk is not null) + TableScan [TS_6] (rows=1704 width=90) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=221) + Conds:RS_94._col0=RS_86._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_86] + PartitionCols:_col0 + Select Operator [SEL_85] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_84] (rows=652 width=8) + predicate:((d_year = 1999) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_94] + PartitionCols:_col0 + Select Operator [SEL_93] (rows=525329897 width=225) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_92] (rows=525329897 width=225) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_13_d1_d_date_sk_min) AND DynamicValue(RS_13_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_13_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=225) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] + <-Reducer 9 [BROADCAST_EDGE] vectorized + BROADCAST [RS_91] + Group By Operator [GBY_90] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_89] + Group By Operator [GBY_88] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_87] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_85] diff --git ql/src/test/results/clientpositive/perf/tez/query37.q.out ql/src/test/results/clientpositive/perf/tez/query37.q.out index 2724fd44dc..3b085cbf2f 100644 --- ql/src/test/results/clientpositive/perf/tez/query37.q.out +++ ql/src/test/results/clientpositive/perf/tez/query37.q.out @@ -56,78 +56,78 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_101] - Limit [LIM_100] (rows=4 width=396) + File Output Operator [FS_106] + Limit [LIM_105] (rows=4 width=396) Number of rows:100 - Select Operator [SEL_99] (rows=4 width=396) + Select Operator [SEL_104] (rows=4 width=396) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_98] - Group By Operator [GBY_97] (rows=4 width=396) + SHUFFLE [RS_103] + Group By Operator [GBY_102] (rows=4 width=396) Output:["_col0","_col1","_col2"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_23] (rows=8 width=396) Output:["_col0","_col1","_col2"],keys:_col2, _col3, _col4 - Top N Key Operator [TNK_43] (rows=11627 width=396) + Top N Key Operator [TNK_48] (rows=11627 width=396) keys:_col2, _col3, _col4,top n:100 - Merge Join Operator [MERGEJOIN_79] (rows=11627 width=396) + Merge Join Operator [MERGEJOIN_84] (rows=11627 width=396) Conds:RS_19._col1=RS_20._col1(Inner),Output:["_col2","_col3","_col4"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_77] (rows=1781971 width=400) - Conds:RS_90._col0=RS_82._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_82] (rows=1781971 width=400) + Conds:RS_95._col0=RS_87._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_82] + PARTITION_ONLY_SHUFFLE [RS_87] PartitionCols:_col0 - Select Operator [SEL_81] (rows=297 width=400) + Select Operator [SEL_86] (rows=297 width=400) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_80] (rows=297 width=404) + Filter Operator [FIL_85] (rows=297 width=404) predicate:(i_current_price BETWEEN 22 AND 52 and (i_manufact_id) IN (678, 964, 918, 849) and i_item_sk is not null) TableScan [TS_3] (rows=462000 width=403) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_manufact_id"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_90] + SHUFFLE [RS_95] PartitionCols:_col0 - Select Operator [SEL_89] (rows=287989836 width=4) + Select Operator [SEL_94] (rows=287989836 width=4) Output:["_col0"] - Filter Operator [FIL_88] (rows=287989836 width=4) + Filter Operator [FIL_93] (rows=287989836 width=4) predicate:(cs_item_sk is not null and cs_item_sk BETWEEN DynamicValue(RS_17_item_i_item_sk_min) AND DynamicValue(RS_17_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, DynamicValue(RS_17_item_i_item_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=4) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_item_sk"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_87] - Group By Operator [GBY_86] (rows=1 width=12) + BROADCAST [RS_92] + Group By Operator [GBY_91] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_85] - Group By Operator [GBY_84] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_90] + Group By Operator [GBY_89] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_83] (rows=297 width=4) + Select Operator [SEL_88] (rows=297 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_81] + Please refer to the previous Select Operator [SEL_86] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_78] (rows=1879072 width=4) - Conds:RS_93._col0=RS_96._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_83] (rows=1879072 width=4) + Conds:RS_98._col0=RS_101._col0(Inner),Output:["_col1"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] + SHUFFLE [RS_101] PartitionCols:_col0 - Select Operator [SEL_95] (rows=8116 width=4) + Select Operator [SEL_100] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_94] (rows=8116 width=98) + Filter Operator [FIL_99] (rows=8116 width=98) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2001-06-02 00:00:00' AND TIMESTAMP'2001-08-01 00:00:00' and d_date_sk is not null) TableScan [TS_9] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_93] + SHUFFLE [RS_98] PartitionCols:_col0 - Select Operator [SEL_92] (rows=16912800 width=8) + Select Operator [SEL_97] (rows=16912800 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_91] (rows=16912800 width=11) + Filter Operator [FIL_96] (rows=16912800 width=11) predicate:(inv_quantity_on_hand BETWEEN 100 AND 500 and inv_item_sk is not null and inv_date_sk is not null) TableScan [TS_6] (rows=37584000 width=11) default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_quantity_on_hand"] diff --git ql/src/test/results/clientpositive/perf/tez/query4.q.out ql/src/test/results/clientpositive/perf/tez/query4.q.out index 99552295f0..0ffb89ac25 100644 --- ql/src/test/results/clientpositive/perf/tez/query4.q.out +++ ql/src/test/results/clientpositive/perf/tez/query4.q.out @@ -271,355 +271,357 @@ Stage-0 limit:100 Stage-1 Reducer 10 vectorized - File Output Operator [FS_569] - Limit [LIM_568] (rows=100 width=85) + File Output Operator [FS_570] + Limit [LIM_569] (rows=100 width=85) Number of rows:100 - Select Operator [SEL_567] (rows=11399756 width=85) + Select Operator [SEL_568] (rows=11399756 width=85) Output:["_col0"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_141] Select Operator [SEL_140] (rows=11399756 width=85) Output:["_col0"] - Filter Operator [FIL_139] (rows=11399756 width=537) - predicate:CASE WHEN (_col3 is not null) THEN (CASE WHEN (_col9) THEN (((_col11 / _col8) > (_col14 / _col3))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_472] (rows=22799512 width=537) - Conds:RS_136._col2=RS_566._col0(Inner),Output:["_col3","_col8","_col9","_col11","_col13","_col14"] - <-Reducer 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_566] - PartitionCols:_col0 - Select Operator [SEL_565] (rows=80000000 width=297) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_564] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 29 [SIMPLE_EDGE] - SHUFFLE [RS_120] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_119] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_467] (rows=525327388 width=764) - Conds:RS_115._col1=RS_512._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_512] + Top N Key Operator [TNK_256] (rows=11399756 width=537) + keys:_col13,top n:100 + Filter Operator [FIL_139] (rows=11399756 width=537) + predicate:CASE WHEN (_col3 is not null) THEN (CASE WHEN (_col9) THEN (((_col11 / _col8) > (_col14 / _col3))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_473] (rows=22799512 width=537) + Conds:RS_136._col2=RS_567._col0(Inner),Output:["_col3","_col8","_col9","_col11","_col13","_col14"] + <-Reducer 30 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_567] + PartitionCols:_col0 + Select Operator [SEL_566] (rows=80000000 width=297) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_565] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 29 [SIMPLE_EDGE] + SHUFFLE [RS_120] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_119] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_468] (rows=525327388 width=764) + Conds:RS_115._col1=RS_513._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_513] + PartitionCols:_col0 + Select Operator [SEL_512] (rows=80000000 width=656) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_511] (rows=80000000 width=656) + predicate:(c_customer_sk is not null and c_customer_id is not null) + TableScan [TS_109] (rows=80000000 width=656) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] + <-Reducer 28 [SIMPLE_EDGE] + SHUFFLE [RS_115] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_467] (rows=525327388 width=115) + Conds:RS_564._col0=RS_482._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_482] + PartitionCols:_col0 + Select Operator [SEL_478] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_474] (rows=652 width=8) + predicate:((d_year = 2002) and d_date_sk is not null) + TableScan [TS_106] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_564] + PartitionCols:_col0 + Select Operator [SEL_563] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_562] (rows=525327388 width=435) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_113_date_dim_d_date_sk_min) AND DynamicValue(RS_113_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_113_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_103] (rows=575995635 width=435) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] + <-Reducer 32 [BROADCAST_EDGE] vectorized + BROADCAST [RS_561] + Group By Operator [GBY_560] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_500] + Group By Operator [GBY_494] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_483] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_478] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_136] + PartitionCols:_col2 + Filter Operator [FIL_135] (rows=19066162 width=668) + predicate:CASE WHEN (_col6) THEN (CASE WHEN (_col9) THEN (((_col11 / _col8) > (_col1 / _col5))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_472] (rows=38132324 width=668) + Conds:RS_132._col2=RS_559._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col8","_col9","_col11"] + <-Reducer 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_559] + PartitionCols:_col0 + Select Operator [SEL_558] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_557] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 25 [SIMPLE_EDGE] + SHUFFLE [RS_100] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_99] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_466] (rows=285117831 width=764) + Conds:RS_95._col1=RS_514._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_514] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_512] + <-Reducer 24 [SIMPLE_EDGE] + SHUFFLE [RS_95] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_465] (rows=285117831 width=115) + Conds:RS_556._col0=RS_484._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_484] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_478] + <-Map 23 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_556] + PartitionCols:_col0 + Select Operator [SEL_555] (rows=285117831 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_554] (rows=285117831 width=453) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_93_date_dim_d_date_sk_min) AND DynamicValue(RS_93_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_93_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_83] (rows=287989836 width=453) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] + <-Reducer 33 [BROADCAST_EDGE] vectorized + BROADCAST [RS_553] + Group By Operator [GBY_552] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_501] + Group By Operator [GBY_495] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_485] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_478] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_132] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_471] (rows=31888273 width=556) + Conds:RS_129._col2=RS_551._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col8","_col9"] + <-Reducer 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_551] PartitionCols:_col0 - Select Operator [SEL_511] (rows=80000000 width=656) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_510] (rows=80000000 width=656) - predicate:(c_customer_sk is not null and c_customer_id is not null) - TableScan [TS_109] (rows=80000000 width=656) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name","c_preferred_cust_flag","c_birth_country","c_login","c_email_address"] - <-Reducer 28 [SIMPLE_EDGE] - SHUFFLE [RS_115] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_466] (rows=525327388 width=115) - Conds:RS_563._col0=RS_481._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_481] - PartitionCols:_col0 - Select Operator [SEL_477] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_473] (rows=652 width=8) - predicate:((d_year = 2002) and d_date_sk is not null) - TableScan [TS_106] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_563] + Select Operator [SEL_550] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_549] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_548] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_547] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_79] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_78] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_464] (rows=285117831 width=764) + Conds:RS_74._col1=RS_518._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_518] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_512] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_74] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_463] (rows=285117831 width=115) + Conds:RS_546._col0=RS_492._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_492] + PartitionCols:_col0 + Select Operator [SEL_481] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_477] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_106] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_546] + PartitionCols:_col0 + Select Operator [SEL_545] (rows=285117831 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_544] (rows=285117831 width=453) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_72_date_dim_d_date_sk_min) AND DynamicValue(RS_72_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_72_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_62] (rows=287989836 width=453) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] + <-Reducer 37 [BROADCAST_EDGE] vectorized + BROADCAST [RS_543] + Group By Operator [GBY_542] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_505] + Group By Operator [GBY_499] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_493] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_481] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_129] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_470] (rows=31888273 width=440) + Conds:RS_126._col2=RS_541._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Reducer 18 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_541] PartitionCols:_col0 - Select Operator [SEL_562] (rows=525327388 width=119) + Select Operator [SEL_540] (rows=26666666 width=216) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_561] (rows=525327388 width=435) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_113_date_dim_d_date_sk_min) AND DynamicValue(RS_113_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_113_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_103] (rows=575995635 width=435) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] - <-Reducer 32 [BROADCAST_EDGE] vectorized - BROADCAST [RS_560] - Group By Operator [GBY_559] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_499] - Group By Operator [GBY_493] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_482] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_477] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_136] - PartitionCols:_col2 - Filter Operator [FIL_135] (rows=19066162 width=668) - predicate:CASE WHEN (_col6) THEN (CASE WHEN (_col9) THEN (((_col11 / _col8) > (_col1 / _col5))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_471] (rows=38132324 width=668) - Conds:RS_132._col2=RS_558._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col8","_col9","_col11"] - <-Reducer 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_558] - PartitionCols:_col0 - Select Operator [SEL_557] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_556] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 25 [SIMPLE_EDGE] - SHUFFLE [RS_100] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_99] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_465] (rows=285117831 width=764) - Conds:RS_95._col1=RS_513._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_513] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_511] - <-Reducer 24 [SIMPLE_EDGE] - SHUFFLE [RS_95] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_464] (rows=285117831 width=115) - Conds:RS_555._col0=RS_483._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_483] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_477] - <-Map 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_555] - PartitionCols:_col0 - Select Operator [SEL_554] (rows=285117831 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_553] (rows=285117831 width=453) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_93_date_dim_d_date_sk_min) AND DynamicValue(RS_93_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_93_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_83] (rows=287989836 width=453) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] - <-Reducer 33 [BROADCAST_EDGE] vectorized - BROADCAST [RS_552] - Group By Operator [GBY_551] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_500] - Group By Operator [GBY_494] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_484] (rows=652 width=4) + Filter Operator [FIL_539] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_538] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_537] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 17 [SIMPLE_EDGE] + SHUFFLE [RS_58] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_57] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_462] (rows=143930993 width=764) + Conds:RS_53._col1=RS_517._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_517] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_512] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_53] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_461] (rows=143930993 width=115) + Conds:RS_536._col0=RS_490._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_490] + PartitionCols:_col0 + Select Operator [SEL_480] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_477] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_132] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_470] (rows=31888273 width=556) - Conds:RS_129._col2=RS_550._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col8","_col9"] - <-Reducer 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_550] - PartitionCols:_col0 - Select Operator [SEL_549] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_548] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_547] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_546] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_79] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_78] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_463] (rows=285117831 width=764) - Conds:RS_74._col1=RS_517._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_517] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_511] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_74] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_462] (rows=285117831 width=115) - Conds:RS_545._col0=RS_491._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_491] - PartitionCols:_col0 - Select Operator [SEL_480] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_476] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_106] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_545] - PartitionCols:_col0 - Select Operator [SEL_544] (rows=285117831 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_543] (rows=285117831 width=453) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_72_date_dim_d_date_sk_min) AND DynamicValue(RS_72_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_72_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_62] (rows=287989836 width=453) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_ext_discount_amt","cs_ext_sales_price","cs_ext_wholesale_cost","cs_ext_list_price"] - <-Reducer 37 [BROADCAST_EDGE] vectorized - BROADCAST [RS_542] - Group By Operator [GBY_541] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_504] - Group By Operator [GBY_498] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_492] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_480] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_129] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_469] (rows=31888273 width=440) - Conds:RS_126._col2=RS_540._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Reducer 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_540] - PartitionCols:_col0 - Select Operator [SEL_539] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_538] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_537] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_536] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_58] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_57] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_461] (rows=143930993 width=764) - Conds:RS_53._col1=RS_516._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_516] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_511] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_53] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_460] (rows=143930993 width=115) - Conds:RS_535._col0=RS_489._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_489] - PartitionCols:_col0 - Select Operator [SEL_479] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_475] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_106] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_535] - PartitionCols:_col0 - Select Operator [SEL_534] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_533] (rows=143930993 width=455) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_41] (rows=144002668 width=455) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] - <-Reducer 36 [BROADCAST_EDGE] vectorized - BROADCAST [RS_532] - Group By Operator [GBY_531] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_503] - Group By Operator [GBY_497] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_490] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_479] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_126] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_468] (rows=31888273 width=324) - Conds:RS_520._col0=RS_530._col0(Inner),Output:["_col1","_col2","_col3"] - <-Reducer 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_530] - PartitionCols:_col0 - Select Operator [SEL_529] (rows=26666666 width=212) - Output:["_col0","_col1"] - Filter Operator [FIL_528] (rows=26666666 width=212) - predicate:(_col7 > 0) - Select Operator [SEL_527] (rows=80000000 width=212) - Output:["_col0","_col7"] - Group By Operator [GBY_526] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_36] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_459] (rows=525327388 width=764) - Conds:RS_32._col1=RS_515._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_515] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_511] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_458] (rows=525327388 width=115) - Conds:RS_525._col0=RS_487._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_487] - PartitionCols:_col0 - Select Operator [SEL_478] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_474] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_106] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_525] - PartitionCols:_col0 - Select Operator [SEL_524] (rows=525327388 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_523] (rows=525327388 width=435) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=575995635 width=435) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] - <-Reducer 35 [BROADCAST_EDGE] vectorized - BROADCAST [RS_522] - Group By Operator [GBY_521] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_502] - Group By Operator [GBY_496] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_488] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_478] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_520] - PartitionCols:_col0 - Select Operator [SEL_519] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_518] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 - Group By Operator [GBY_16] (rows=80000000 width=764) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 - Merge Join Operator [MERGEJOIN_457] (rows=143930993 width=764) - Conds:RS_12._col1=RS_514._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_514] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_511] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_456] (rows=143930993 width=115) - Conds:RS_509._col0=RS_485._col0(Inner),Output:["_col1","_col2"] - <-Map 31 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_485] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_477] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_509] - PartitionCols:_col0 - Select Operator [SEL_508] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_507] (rows=143930993 width=455) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=455) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] - <-Reducer 34 [BROADCAST_EDGE] vectorized - BROADCAST [RS_506] - Group By Operator [GBY_505] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_501] - Group By Operator [GBY_495] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_486] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_477] + Filter Operator [FIL_476] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_106] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_536] + PartitionCols:_col0 + Select Operator [SEL_535] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_534] (rows=143930993 width=455) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_41] (rows=144002668 width=455) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] + <-Reducer 36 [BROADCAST_EDGE] vectorized + BROADCAST [RS_533] + Group By Operator [GBY_532] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_504] + Group By Operator [GBY_498] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_491] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_480] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_126] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_469] (rows=31888273 width=324) + Conds:RS_521._col0=RS_531._col0(Inner),Output:["_col1","_col2","_col3"] + <-Reducer 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_531] + PartitionCols:_col0 + Select Operator [SEL_530] (rows=26666666 width=212) + Output:["_col0","_col1"] + Filter Operator [FIL_529] (rows=26666666 width=212) + predicate:(_col7 > 0) + Select Operator [SEL_528] (rows=80000000 width=212) + Output:["_col0","_col7"] + Group By Operator [GBY_527] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_36] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_460] (rows=525327388 width=764) + Conds:RS_32._col1=RS_516._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_516] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_512] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_459] (rows=525327388 width=115) + Conds:RS_526._col0=RS_488._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_488] + PartitionCols:_col0 + Select Operator [SEL_479] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_475] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_106] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_526] + PartitionCols:_col0 + Select Operator [SEL_525] (rows=525327388 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_524] (rows=525327388 width=435) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=575995635 width=435) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_discount_amt","ss_ext_sales_price","ss_ext_wholesale_cost","ss_ext_list_price"] + <-Reducer 35 [BROADCAST_EDGE] vectorized + BROADCAST [RS_523] + Group By Operator [GBY_522] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_503] + Group By Operator [GBY_497] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_489] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_479] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_521] + PartitionCols:_col0 + Select Operator [SEL_520] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_519] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6 + Group By Operator [GBY_16] (rows=80000000 width=764) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)"],keys:_col5, _col6, _col7, _col8, _col9, _col10, _col11 + Merge Join Operator [MERGEJOIN_458] (rows=143930993 width=764) + Conds:RS_12._col1=RS_515._col0(Inner),Output:["_col2","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_515] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_512] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_457] (rows=143930993 width=115) + Conds:RS_510._col0=RS_486._col0(Inner),Output:["_col1","_col2"] + <-Map 31 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_486] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_478] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_510] + PartitionCols:_col0 + Select Operator [SEL_509] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_508] (rows=143930993 width=455) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=455) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_ext_discount_amt","ws_ext_sales_price","ws_ext_wholesale_cost","ws_ext_list_price"] + <-Reducer 34 [BROADCAST_EDGE] vectorized + BROADCAST [RS_507] + Group By Operator [GBY_506] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_502] + Group By Operator [GBY_496] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_487] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_478] diff --git ql/src/test/results/clientpositive/perf/tez/query40.q.out ql/src/test/results/clientpositive/perf/tez/query40.q.out index 4b65c82e00..2d368840ae 100644 --- ql/src/test/results/clientpositive/perf/tez/query40.q.out +++ ql/src/test/results/clientpositive/perf/tez/query40.q.out @@ -81,94 +81,94 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_126] - Limit [LIM_125] (rows=100 width=410) + File Output Operator [FS_131] + Limit [LIM_130] (rows=100 width=410) Number of rows:100 - Select Operator [SEL_124] (rows=769995 width=410) + Select Operator [SEL_129] (rows=769995 width=410) Output:["_col0","_col1","_col2","_col3"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_123] - Group By Operator [GBY_122] (rows=769995 width=410) + SHUFFLE [RS_128] + Group By Operator [GBY_127] (rows=769995 width=410) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0, _col1 Group By Operator [GBY_29] (rows=51819042 width=410) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col0, _col1 - Top N Key Operator [TNK_55] (rows=51819042 width=302) - keys:_col0, _col1,top n:100 - Select Operator [SEL_27] (rows=51819042 width=302) - Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_101] (rows=51819042 width=302) - Conds:RS_24._col1=RS_121._col0(Inner),Output:["_col4","_col7","_col9","_col10","_col12","_col14"] + Select Operator [SEL_27] (rows=51819042 width=302) + Output:["_col0","_col1","_col2","_col3"] + Top N Key Operator [TNK_58] (rows=51819042 width=302) + keys:_col14, _col12,top n:100 + Merge Join Operator [MERGEJOIN_106] (rows=51819042 width=302) + Conds:RS_24._col1=RS_126._col0(Inner),Output:["_col4","_col7","_col9","_col10","_col12","_col14"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_121] + SHUFFLE [RS_126] PartitionCols:_col0 - Select Operator [SEL_120] (rows=27 width=90) + Select Operator [SEL_125] (rows=27 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_119] (rows=27 width=90) + Filter Operator [FIL_124] (rows=27 width=90) predicate:w_warehouse_sk is not null TableScan [TS_12] (rows=27 width=90) default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_state"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_100] (rows=51819042 width=220) - Conds:RS_21._col2=RS_104._col0(Inner),Output:["_col1","_col4","_col7","_col9","_col10","_col12"] + Merge Join Operator [MERGEJOIN_105] (rows=51819042 width=220) + Conds:RS_21._col2=RS_109._col0(Inner),Output:["_col1","_col4","_col7","_col9","_col10","_col12"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_104] + SHUFFLE [RS_109] PartitionCols:_col0 - Select Operator [SEL_103] (rows=51333 width=104) + Select Operator [SEL_108] (rows=51333 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_102] (rows=51333 width=215) + Filter Operator [FIL_107] (rows=51333 width=215) predicate:(i_current_price BETWEEN 0.99 AND 1.49 and i_item_sk is not null) TableScan [TS_9] (rows=462000 width=215) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_current_price"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_99] (rows=466374405 width=171) - Conds:RS_18._col0=RS_118._col0(Inner),Output:["_col1","_col2","_col4","_col7","_col9","_col10"] + Merge Join Operator [MERGEJOIN_104] (rows=466374405 width=171) + Conds:RS_18._col0=RS_123._col0(Inner),Output:["_col1","_col2","_col4","_col7","_col9","_col10"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_118] + SHUFFLE [RS_123] PartitionCols:_col0 - Select Operator [SEL_117] (rows=8116 width=12) + Select Operator [SEL_122] (rows=8116 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_116] (rows=8116 width=98) + Filter Operator [FIL_121] (rows=8116 width=98) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-03-09 00:00:00' AND TIMESTAMP'1998-05-08 00:00:00' and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_98] (rows=466374405 width=167) - Conds:RS_112._col2, _col3=RS_115._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col7"] + Merge Join Operator [MERGEJOIN_103] (rows=466374405 width=167) + Conds:RS_117._col2, _col3=RS_120._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col7"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_112] + SHUFFLE [RS_117] PartitionCols:_col2, _col3 - Select Operator [SEL_111] (rows=285115816 width=127) + Select Operator [SEL_116] (rows=285115816 width=127) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_110] (rows=285115816 width=127) + Filter Operator [FIL_115] (rows=285115816 width=127) predicate:(cs_warehouse_sk is not null and cs_sold_date_sk is not null and cs_item_sk is not null and cs_item_sk BETWEEN DynamicValue(RS_22_item_i_item_sk_min) AND DynamicValue(RS_22_item_i_item_sk_max) and in_bloom_filter(cs_item_sk, DynamicValue(RS_22_item_i_item_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=127) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_warehouse_sk","cs_item_sk","cs_order_number","cs_sales_price"] <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_109] - Group By Operator [GBY_108] (rows=1 width=12) + BROADCAST [RS_114] + Group By Operator [GBY_113] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_107] - Group By Operator [GBY_106] (rows=1 width=12) + SHUFFLE [RS_112] + Group By Operator [GBY_111] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_105] (rows=51333 width=4) + Select Operator [SEL_110] (rows=51333 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_103] + Please refer to the previous Select Operator [SEL_108] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_115] + SHUFFLE [RS_120] PartitionCols:_col0, _col1 - Select Operator [SEL_114] (rows=28798881 width=117) + Select Operator [SEL_119] (rows=28798881 width=117) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_113] (rows=28798881 width=117) + Filter Operator [FIL_118] (rows=28798881 width=117) predicate:(cr_order_number is not null and cr_item_sk is not null) TableScan [TS_3] (rows=28798881 width=117) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_refunded_cash"] diff --git ql/src/test/results/clientpositive/perf/tez/query42.q.out ql/src/test/results/clientpositive/perf/tez/query42.q.out index 3c059f85f6..45865d0daa 100644 --- ql/src/test/results/clientpositive/perf/tez/query42.q.out +++ ql/src/test/results/clientpositive/perf/tez/query42.q.out @@ -63,65 +63,67 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Limit [LIM_73] (rows=100 width=210) + File Output Operator [FS_76] + Limit [LIM_75] (rows=100 width=210) Number of rows:100 - Select Operator [SEL_72] (rows=110 width=210) + Select Operator [SEL_74] (rows=110 width=210) Output:["_col0","_col1","_col2","_col3"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - Select Operator [SEL_70] (rows=110 width=318) + SHUFFLE [RS_73] + Select Operator [SEL_72] (rows=110 width=318) Output:["_col0","_col1","_col3"] - Group By Operator [GBY_69] (rows=110 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1 - Group By Operator [GBY_16] (rows=6840 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 - Merge Join Operator [MERGEJOIN_54] (rows=84037218 width=173) - Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_68] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=7333 width=97) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_66] (rows=7333 width=101) - predicate:((i_manager_id = 1) and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=101) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category_id","i_category","i_manager_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_53] (rows=550076554 width=110) - Conds:RS_65._col0=RS_57._col0(Inner),Output:["_col1","_col2"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_57] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_55] (rows=50 width=12) - predicate:((d_year = 1998) and (d_moy = 12) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_63] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_62] - Group By Operator [GBY_61] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_60] - Group By Operator [GBY_59] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_58] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_56] + Top N Key Operator [TNK_71] (rows=110 width=206) + keys:_col2, _col0, _col1,top n:100 + Group By Operator [GBY_70] (rows=110 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1 + Group By Operator [GBY_16] (rows=6840 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 + Merge Join Operator [MERGEJOIN_55] (rows=84037218 width=173) + Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] + PartitionCols:_col0 + Select Operator [SEL_68] (rows=7333 width=97) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_67] (rows=7333 width=101) + predicate:((i_manager_id = 1) and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=101) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category_id","i_category","i_manager_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_54] (rows=550076554 width=110) + Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_56] (rows=50 width=12) + predicate:((d_year = 1998) and (d_moy = 12) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/query43.q.out ql/src/test/results/clientpositive/perf/tez/query43.q.out index eb19d41926..3205aa83e5 100644 --- ql/src/test/results/clientpositive/perf/tez/query43.q.out +++ ql/src/test/results/clientpositive/perf/tez/query43.q.out @@ -57,67 +57,69 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Limit [LIM_73] (rows=100 width=972) + File Output Operator [FS_80] + Limit [LIM_79] (rows=100 width=972) Number of rows:100 - Select Operator [SEL_72] (rows=3751 width=972) + Select Operator [SEL_78] (rows=3751 width=972) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - Group By Operator [GBY_70] (rows=3751 width=972) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col0, _col1 - Group By Operator [GBY_17] (rows=2486913 width=972) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 - Top N Key Operator [TNK_33] (rows=525329897 width=322) - keys:_col0, _col1,top n:100 + SHUFFLE [RS_77] + Top N Key Operator [TNK_76] (rows=3751 width=972) + keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8,top n:100 + Group By Operator [GBY_75] (rows=3751 width=972) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0, _col1 + Group By Operator [GBY_17] (rows=2486913 width=972) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 Select Operator [SEL_15] (rows=525329897 width=322) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_55] (rows=525329897 width=322) - Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col12","_col13"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_69] - PartitionCols:_col0 - Select Operator [SEL_68] (rows=341 width=192) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_67] (rows=341 width=303) - predicate:((s_gmt_offset = -6) and s_store_sk is not null) - TableScan [TS_6] (rows=1704 width=303) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name","s_gmt_offset"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_54] (rows=525329897 width=138) - Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_58] - PartitionCols:_col0 - Select Operator [SEL_57] (rows=652 width=32) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_56] (rows=652 width=99) - predicate:((d_year = 1998) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=99) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_day_name"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_66] - PartitionCols:_col0 - Select Operator [SEL_65] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_64] (rows=525329897 width=114) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_63] - Group By Operator [GBY_62] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_61] - Group By Operator [GBY_60] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_59] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_57] + Top N Key Operator [TNK_36] (rows=525329897 width=322) + keys:_col13, _col12,top n:100 + Merge Join Operator [MERGEJOIN_60] (rows=525329897 width=322) + Conds:RS_12._col1=RS_74._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col12","_col13"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_74] + PartitionCols:_col0 + Select Operator [SEL_73] (rows=341 width=192) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_72] (rows=341 width=303) + predicate:((s_gmt_offset = -6) and s_store_sk is not null) + TableScan [TS_6] (rows=1704 width=303) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name","s_gmt_offset"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_59] (rows=525329897 width=138) + Conds:RS_71._col0=RS_63._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_62] (rows=652 width=32) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_61] (rows=652 width=99) + predicate:((d_year = 1998) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=99) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_day_name"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_71] + PartitionCols:_col0 + Select Operator [SEL_70] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_69] (rows=525329897 width=114) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_68] + Group By Operator [GBY_67] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_66] + Group By Operator [GBY_65] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_64] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_62] diff --git ql/src/test/results/clientpositive/perf/tez/query44.q.out ql/src/test/results/clientpositive/perf/tez/query44.q.out index adaea8c46e..a0defab8b3 100644 --- ql/src/test/results/clientpositive/perf/tez/query44.q.out +++ ql/src/test/results/clientpositive/perf/tez/query44.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[109][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 8' is a cross product +Warning: Shuffle Join MERGEJOIN[110][tables = [$hdt$_1, $hdt$_2]] in Stage 'Reducer 8' is a cross product PREHOOK: query: explain select asceding.rnk, i1.i_product_name best_performing, i2.i_product_name worst_performing from(select * @@ -91,111 +91,113 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_147] - Limit [LIM_146] (rows=100 width=218) + File Output Operator [FS_148] + Limit [LIM_147] (rows=100 width=218) Number of rows:100 - Select Operator [SEL_145] (rows=6951 width=218) + Select Operator [SEL_146] (rows=6951 width=218) Output:["_col0","_col1","_col2"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_73] Select Operator [SEL_72] (rows=6951 width=218) Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_113] (rows=6951 width=218) - Conds:RS_69._col3=RS_70._col3(Inner),Output:["_col1","_col3","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_69] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_110] (rows=6951 width=111) - Conds:RS_116._col0=RS_139._col0(Inner),Output:["_col1","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_116] - PartitionCols:_col0 - Select Operator [SEL_115] (rows=462000 width=111) - Output:["_col0","_col1"] - Filter Operator [FIL_114] (rows=462000 width=111) - predicate:i_item_sk is not null - TableScan [TS_0] (rows=462000 width=111) - default@item,i1,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_product_name"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_139] - PartitionCols:_col0 - Select Operator [SEL_138] (rows=6951 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_137] (rows=6951 width=116) - predicate:((rank_window_0 < 11) and _col0 is not null) - PTF Operator [PTF_136] (rows=20854 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_135] (rows=20854 width=116) - Output:["_col0","_col1"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:0 - Filter Operator [FIL_23] (rows=20854 width=228) - predicate:(_col1 > (0.9 * _col2)) - Merge Join Operator [MERGEJOIN_109] (rows=62562 width=228) - Conds:(Inner),Output:["_col0","_col1","_col2"] - <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_134] - Select Operator [SEL_133] (rows=1 width=112) - Output:["_col0"] - Filter Operator [FIL_132] (rows=1 width=120) - predicate:(_col1 is not null and _col2 is not null) - Select Operator [SEL_131] (rows=1 width=120) - Output:["_col1","_col2"] - Group By Operator [GBY_130] (rows=1 width=124) + Top N Key Operator [TNK_99] (rows=6951 width=218) + keys:_col3,top n:100 + Merge Join Operator [MERGEJOIN_114] (rows=6951 width=218) + Conds:RS_69._col3=RS_70._col3(Inner),Output:["_col1","_col3","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_69] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_111] (rows=6951 width=111) + Conds:RS_117._col0=RS_140._col0(Inner),Output:["_col1","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_117] + PartitionCols:_col0 + Select Operator [SEL_116] (rows=462000 width=111) + Output:["_col0","_col1"] + Filter Operator [FIL_115] (rows=462000 width=111) + predicate:i_item_sk is not null + TableScan [TS_0] (rows=462000 width=111) + default@item,i1,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_product_name"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_140] + PartitionCols:_col0 + Select Operator [SEL_139] (rows=6951 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_138] (rows=6951 width=116) + predicate:((rank_window_0 < 11) and _col0 is not null) + PTF Operator [PTF_137] (rows=20854 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"0"}] + Select Operator [SEL_136] (rows=20854 width=116) + Output:["_col0","_col1"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:0 + Filter Operator [FIL_23] (rows=20854 width=228) + predicate:(_col1 > (0.9 * _col2)) + Merge Join Operator [MERGEJOIN_110] (rows=62562 width=228) + Conds:(Inner),Output:["_col0","_col1","_col2"] + <-Reducer 12 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_135] + Select Operator [SEL_134] (rows=1 width=112) + Output:["_col0"] + Filter Operator [FIL_133] (rows=1 width=120) + predicate:(_col1 is not null and _col2 is not null) + Select Operator [SEL_132] (rows=1 width=120) + Output:["_col1","_col2"] + Group By Operator [GBY_131] (rows=1 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_130] + PartitionCols:_col0 + Group By Operator [GBY_129] (rows=258 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","count(_col1)"],keys:true + Select Operator [SEL_128] (rows=287946 width=114) + Output:["_col1"] + Filter Operator [FIL_127] (rows=287946 width=114) + predicate:(ss_hdemo_sk is null and (ss_store_sk = 410)) + TableScan [TS_11] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_hdemo_sk","ss_store_sk","ss_net_profit"] + <-Reducer 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_126] + Select Operator [SEL_125] (rows=62562 width=116) + Output:["_col0","_col1"] + Filter Operator [FIL_124] (rows=62562 width=124) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_123] (rows=62562 width=124) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_129] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_122] PartitionCols:_col0 - Group By Operator [GBY_128] (rows=258 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col1)","count(_col1)"],keys:true - Select Operator [SEL_127] (rows=287946 width=114) - Output:["_col1"] - Filter Operator [FIL_126] (rows=287946 width=114) - predicate:(ss_hdemo_sk is null and (ss_store_sk = 410)) - TableScan [TS_11] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_hdemo_sk","ss_store_sk","ss_net_profit"] - <-Reducer 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_125] - Select Operator [SEL_124] (rows=62562 width=116) - Output:["_col0","_col1"] - Filter Operator [FIL_123] (rows=62562 width=124) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_122] (rows=62562 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_121] - PartitionCols:_col0 - Group By Operator [GBY_120] (rows=3199976 width=124) - Output:["_col0","_col1","_col2"],aggregations:["sum(ss_net_profit)","count(ss_net_profit)"],keys:ss_item_sk - Select Operator [SEL_119] (rows=6399952 width=114) - Output:["ss_item_sk","ss_net_profit"] - Filter Operator [FIL_118] (rows=6399952 width=114) - predicate:(ss_store_sk = 410) - TableScan [TS_3] (rows=575995635 width=114) - default@store_sales,ss1,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_store_sk","ss_net_profit"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_70] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_112] (rows=6951 width=111) - Conds:RS_117._col0=RS_144._col0(Inner),Output:["_col1","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_115] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] - PartitionCols:_col0 - Select Operator [SEL_143] (rows=6951 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_142] (rows=6951 width=116) - predicate:((rank_window_0 < 11) and _col0 is not null) - PTF Operator [PTF_141] (rows=20854 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_140] (rows=20854 width=116) - Output:["_col0","_col1"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_55] - PartitionCols:0 - Please refer to the previous Filter Operator [FIL_23] + Group By Operator [GBY_121] (rows=3199976 width=124) + Output:["_col0","_col1","_col2"],aggregations:["sum(ss_net_profit)","count(ss_net_profit)"],keys:ss_item_sk + Select Operator [SEL_120] (rows=6399952 width=114) + Output:["ss_item_sk","ss_net_profit"] + Filter Operator [FIL_119] (rows=6399952 width=114) + predicate:(ss_store_sk = 410) + TableScan [TS_3] (rows=575995635 width=114) + default@store_sales,ss1,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_store_sk","ss_net_profit"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_70] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_113] (rows=6951 width=111) + Conds:RS_118._col0=RS_145._col0(Inner),Output:["_col1","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_118] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_116] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_145] + PartitionCols:_col0 + Select Operator [SEL_144] (rows=6951 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_143] (rows=6951 width=116) + predicate:((rank_window_0 < 11) and _col0 is not null) + PTF Operator [PTF_142] (rows=20854 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"0"}] + Select Operator [SEL_141] (rows=20854 width=116) + Output:["_col0","_col1"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_55] + PartitionCols:0 + Please refer to the previous Filter Operator [FIL_23] diff --git ql/src/test/results/clientpositive/perf/tez/query45.q.out ql/src/test/results/clientpositive/perf/tez/query45.q.out index 4538a6540d..f3f646213f 100644 --- ql/src/test/results/clientpositive/perf/tez/query45.q.out +++ ql/src/test/results/clientpositive/perf/tez/query45.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[133][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product +Warning: Shuffle Join MERGEJOIN[138][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product PREHOOK: query: explain select ca_zip, ca_county, sum(ws_sales_price) from web_sales, customer, customer_address, date_dim, item @@ -70,137 +70,137 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_171] - Limit [LIM_170] (rows=100 width=299) + File Output Operator [FS_176] + Limit [LIM_175] (rows=100 width=299) Number of rows:100 - Select Operator [SEL_169] (rows=17401956 width=299) + Select Operator [SEL_174] (rows=17401956 width=299) Output:["_col0","_col1","_col2"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_168] - Group By Operator [GBY_167] (rows=17401956 width=299) + SHUFFLE [RS_173] + Group By Operator [GBY_172] (rows=17401956 width=299) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_53] PartitionCols:_col0, _col1 Group By Operator [GBY_52] (rows=143930993 width=299) Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col8, _col7 - Top N Key Operator [TNK_82] (rows=143930993 width=310) - keys:_col8, _col7,top n:100 - Select Operator [SEL_51] (rows=143930993 width=310) - Output:["_col3","_col7","_col8"] + Select Operator [SEL_51] (rows=143930993 width=310) + Output:["_col3","_col7","_col8"] + Top N Key Operator [TNK_85] (rows=143930993 width=310) + keys:_col8, _col7,top n:100 Filter Operator [FIL_50] (rows=143930993 width=310) predicate:(((_col14 <> 0L) and _col16 is not null) or (substr(_col8, 1, 5)) IN ('85669', '86197', '88274', '83405', '86475', '85392', '85460', '80348', '81792')) Select Operator [SEL_49] (rows=143930993 width=310) Output:["_col3","_col7","_col8","_col14","_col16"] - Merge Join Operator [MERGEJOIN_133] (rows=143930993 width=310) + Merge Join Operator [MERGEJOIN_138] (rows=143930993 width=310) Conds:(Inner),Output:["_col3","_col4","_col8","_col12","_col16"] <-Reducer 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_166] - Group By Operator [GBY_165] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_171] + Group By Operator [GBY_170] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] <-Map 16 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_164] - Group By Operator [GBY_163] (rows=1 width=8) + PARTITION_ONLY_SHUFFLE [RS_169] + Group By Operator [GBY_168] (rows=1 width=8) Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_162] (rows=11 width=4) - Filter Operator [FIL_161] (rows=11 width=4) + Select Operator [SEL_167] (rows=11 width=4) + Filter Operator [FIL_166] (rows=11 width=4) predicate:(i_item_sk) IN (2, 3, 5, 7, 11, 13, 17, 19, 23, 29) TableScan [TS_33] (rows=462000 width=4) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk"] <-Reducer 3 [CUSTOM_SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_46] - Merge Join Operator [MERGEJOIN_132] (rows=143930993 width=302) + Merge Join Operator [MERGEJOIN_137] (rows=143930993 width=302) Conds:RS_43._col0=RS_44._col6(Inner),Output:["_col3","_col4","_col8","_col12"] <-Reducer 10 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col6 - Merge Join Operator [MERGEJOIN_131] (rows=143930993 width=119) + Merge Join Operator [MERGEJOIN_136] (rows=143930993 width=119) Conds:RS_29._col0=RS_30._col1(Inner),Output:["_col3","_col6","_col7"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_130] (rows=143930993 width=119) - Conds:RS_160._col0=RS_152._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_135] (rows=143930993 width=119) + Conds:RS_165._col0=RS_157._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 14 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_152] + PARTITION_ONLY_SHUFFLE [RS_157] PartitionCols:_col0 - Select Operator [SEL_151] (rows=130 width=12) + Select Operator [SEL_156] (rows=130 width=12) Output:["_col0"] - Filter Operator [FIL_150] (rows=130 width=12) + Filter Operator [FIL_155] (rows=130 width=12) predicate:((d_year = 2000) and (d_qoy = 2) and d_date_sk is not null) TableScan [TS_19] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_160] + SHUFFLE [RS_165] PartitionCols:_col0 - Select Operator [SEL_159] (rows=143930993 width=123) + Select Operator [SEL_164] (rows=143930993 width=123) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_158] (rows=143930993 width=123) + Filter Operator [FIL_163] (rows=143930993 width=123) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_23_date_dim_d_date_sk_min) AND DynamicValue(RS_23_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_23_date_dim_d_date_sk_bloom_filter))) TableScan [TS_16] (rows=144002668 width=123) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_sales_price"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_157] - Group By Operator [GBY_156] (rows=1 width=12) + BROADCAST [RS_162] + Group By Operator [GBY_161] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_155] - Group By Operator [GBY_154] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_160] + Group By Operator [GBY_159] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_153] (rows=130 width=4) + Select Operator [SEL_158] (rows=130 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_151] + Please refer to the previous Select Operator [SEL_156] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_129] (rows=462007 width=4) - Conds:RS_144._col1=RS_149._col0(Left Outer),Output:["_col0","_col3"] + Merge Join Operator [MERGEJOIN_134] (rows=462007 width=4) + Conds:RS_149._col1=RS_154._col0(Left Outer),Output:["_col0","_col3"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] + SHUFFLE [RS_149] PartitionCols:_col1 - Select Operator [SEL_142] (rows=462000 width=104) + Select Operator [SEL_147] (rows=462000 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_140] (rows=462000 width=104) + Filter Operator [FIL_145] (rows=462000 width=104) predicate:i_item_sk is not null TableScan [TS_6] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_149] + SHUFFLE [RS_154] PartitionCols:_col0 - Select Operator [SEL_148] (rows=5 width=104) + Select Operator [SEL_153] (rows=5 width=104) Output:["_col0","_col1"] - Group By Operator [GBY_147] (rows=5 width=100) + Group By Operator [GBY_152] (rows=5 width=100) Output:["_col0"],keys:KEY._col0 <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] + SHUFFLE [RS_151] PartitionCols:_col0 - Group By Operator [GBY_145] (rows=5 width=100) + Group By Operator [GBY_150] (rows=5 width=100) Output:["_col0"],keys:i_item_id - Select Operator [SEL_143] (rows=11 width=104) + Select Operator [SEL_148] (rows=11 width=104) Output:["i_item_id"] - Filter Operator [FIL_141] (rows=11 width=104) + Filter Operator [FIL_146] (rows=11 width=104) predicate:((i_item_sk) IN (2, 3, 5, 7, 11, 13, 17, 19, 23, 29) and i_item_id is not null) Please refer to the previous TableScan [TS_6] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_43] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_128] (rows=80000000 width=191) - Conds:RS_136._col1=RS_139._col0(Inner),Output:["_col0","_col3","_col4"] + Merge Join Operator [MERGEJOIN_133] (rows=80000000 width=191) + Conds:RS_141._col1=RS_144._col0(Inner),Output:["_col0","_col3","_col4"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_136] + SHUFFLE [RS_141] PartitionCols:_col1 - Select Operator [SEL_135] (rows=80000000 width=8) + Select Operator [SEL_140] (rows=80000000 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_134] (rows=80000000 width=8) + Filter Operator [FIL_139] (rows=80000000 width=8) predicate:(c_customer_sk is not null and c_current_addr_sk is not null) TableScan [TS_0] (rows=80000000 width=8) default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_139] + SHUFFLE [RS_144] PartitionCols:_col0 - Select Operator [SEL_138] (rows=40000000 width=191) + Select Operator [SEL_143] (rows=40000000 width=191) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_137] (rows=40000000 width=191) + Filter Operator [FIL_142] (rows=40000000 width=191) predicate:ca_address_sk is not null TableScan [TS_3] (rows=40000000 width=191) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_zip"] diff --git ql/src/test/results/clientpositive/perf/tez/query46.q.out ql/src/test/results/clientpositive/perf/tez/query46.q.out index 3e6358d907..fbdf263b43 100644 --- ql/src/test/results/clientpositive/perf/tez/query46.q.out +++ ql/src/test/results/clientpositive/perf/tez/query46.q.out @@ -99,120 +99,122 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_175] - Limit [LIM_174] (rows=100 width=594) + File Output Operator [FS_176] + Limit [LIM_175] (rows=100 width=594) Number of rows:100 - Select Operator [SEL_173] (rows=457565061 width=594) + Select Operator [SEL_174] (rows=457565061 width=594) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_46] Select Operator [SEL_45] (rows=457565061 width=594) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_44] (rows=457565061 width=594) - predicate:(_col5 <> _col8) - Merge Join Operator [MERGEJOIN_145] (rows=457565061 width=594) - Conds:RS_41._col0=RS_172._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_41] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_140] (rows=80000000 width=277) - Conds:RS_148._col1=RS_151._col0(Inner),Output:["_col0","_col2","_col3","_col5"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_151] - PartitionCols:_col0 - Select Operator [SEL_150] (rows=40000000 width=97) - Output:["_col0","_col1"] - Filter Operator [FIL_149] (rows=40000000 width=97) - predicate:ca_address_sk is not null - TableScan [TS_3] (rows=40000000 width=97) - default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col1 - Select Operator [SEL_147] (rows=80000000 width=188) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_146] (rows=80000000 width=188) - predicate:(c_customer_sk is not null and c_current_addr_sk is not null) - TableScan [TS_0] (rows=80000000 width=188) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] - <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_172] - PartitionCols:_col1 - Select Operator [SEL_171] (rows=457565061 width=324) - Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_170] (rows=457565061 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_34] (rows=457565061 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col12, _col3, _col5 - Merge Join Operator [MERGEJOIN_144] (rows=457565061 width=318) - Conds:RS_30._col3=RS_152._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col12"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_152] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_150] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=225) - Conds:RS_27._col2=RS_169._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_169] - PartitionCols:_col0 - Select Operator [SEL_168] (rows=1855 width=4) - Output:["_col0"] - Filter Operator [FIL_167] (rows=1855 width=12) - predicate:(((hd_dep_count = 2) or (hd_vehicle_count = 1)) and hd_demo_sk is not null) - TableScan [TS_15] (rows=7200 width=12) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=229) - Conds:RS_24._col4=RS_166._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_166] - PartitionCols:_col0 - Select Operator [SEL_165] (rows=35 width=4) - Output:["_col0"] - Filter Operator [FIL_164] (rows=35 width=97) - predicate:((s_city) IN ('Cedar Grove', 'Wildwood', 'Union', 'Salem', 'Highland Park') and s_store_sk is not null) - TableScan [TS_12] (rows=1704 width=97) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_141] (rows=457565061 width=233) - Conds:RS_163._col0=RS_155._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_155] - PartitionCols:_col0 - Select Operator [SEL_154] (rows=783 width=4) - Output:["_col0"] - Filter Operator [FIL_153] (rows=783 width=12) - predicate:((d_year) IN (1998, 1999, 2000) and (d_dow) IN (6, 0) and d_date_sk is not null) - TableScan [TS_9] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] - PartitionCols:_col0 - Select Operator [SEL_162] (rows=457565061 width=237) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_161] (rows=457565061 width=237) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_6] (rows=575995635 width=237) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_160] - Group By Operator [GBY_159] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_158] - Group By Operator [GBY_157] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_156] (rows=783 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_154] + Top N Key Operator [TNK_80] (rows=457565061 width=594) + keys:_col3, _col2, _col5, _col8, _col6,top n:100 + Filter Operator [FIL_44] (rows=457565061 width=594) + predicate:(_col5 <> _col8) + Merge Join Operator [MERGEJOIN_146] (rows=457565061 width=594) + Conds:RS_41._col0=RS_173._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_41] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_141] (rows=80000000 width=277) + Conds:RS_149._col1=RS_152._col0(Inner),Output:["_col0","_col2","_col3","_col5"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_152] + PartitionCols:_col0 + Select Operator [SEL_151] (rows=40000000 width=97) + Output:["_col0","_col1"] + Filter Operator [FIL_150] (rows=40000000 width=97) + predicate:ca_address_sk is not null + TableScan [TS_3] (rows=40000000 width=97) + default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col1 + Select Operator [SEL_148] (rows=80000000 width=188) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_147] (rows=80000000 width=188) + predicate:(c_customer_sk is not null and c_current_addr_sk is not null) + TableScan [TS_0] (rows=80000000 width=188) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] + <-Reducer 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_173] + PartitionCols:_col1 + Select Operator [SEL_172] (rows=457565061 width=324) + Output:["_col0","_col1","_col2","_col3","_col4"] + Group By Operator [GBY_171] (rows=457565061 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_34] (rows=457565061 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col12, _col3, _col5 + Merge Join Operator [MERGEJOIN_145] (rows=457565061 width=318) + Conds:RS_30._col3=RS_153._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col12"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_153] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_151] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_144] (rows=457565061 width=225) + Conds:RS_27._col2=RS_170._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_170] + PartitionCols:_col0 + Select Operator [SEL_169] (rows=1855 width=4) + Output:["_col0"] + Filter Operator [FIL_168] (rows=1855 width=12) + predicate:(((hd_dep_count = 2) or (hd_vehicle_count = 1)) and hd_demo_sk is not null) + TableScan [TS_15] (rows=7200 width=12) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=229) + Conds:RS_24._col4=RS_167._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_167] + PartitionCols:_col0 + Select Operator [SEL_166] (rows=35 width=4) + Output:["_col0"] + Filter Operator [FIL_165] (rows=35 width=97) + predicate:((s_city) IN ('Cedar Grove', 'Wildwood', 'Union', 'Salem', 'Highland Park') and s_store_sk is not null) + TableScan [TS_12] (rows=1704 width=97) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=233) + Conds:RS_164._col0=RS_156._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_156] + PartitionCols:_col0 + Select Operator [SEL_155] (rows=783 width=4) + Output:["_col0"] + Filter Operator [FIL_154] (rows=783 width=12) + predicate:((d_year) IN (1998, 1999, 2000) and (d_dow) IN (6, 0) and d_date_sk is not null) + TableScan [TS_9] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_164] + PartitionCols:_col0 + Select Operator [SEL_163] (rows=457565061 width=237) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_162] (rows=457565061 width=237) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_6] (rows=575995635 width=237) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_161] + Group By Operator [GBY_160] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_159] + Group By Operator [GBY_158] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_157] (rows=783 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_155] diff --git ql/src/test/results/clientpositive/perf/tez/query47.q.out ql/src/test/results/clientpositive/perf/tez/query47.q.out index e54c366848..d0ffeec603 100644 --- ql/src/test/results/clientpositive/perf/tez/query47.q.out +++ ql/src/test/results/clientpositive/perf/tez/query47.q.out @@ -129,138 +129,140 @@ Stage-0 limit:-1 Stage-1 Reducer 8 vectorized - File Output Operator [FS_321] - Limit [LIM_320] (rows=100 width=658) + File Output Operator [FS_322] + Limit [LIM_321] (rows=100 width=658) Number of rows:100 - Select Operator [SEL_319] (rows=301730 width=658) + Select Operator [SEL_320] (rows=301730 width=658) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_110] Select Operator [SEL_109] (rows=301730 width=658) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_278] (rows=301730 width=546) - Conds:RS_106._col6, _col7, _col8, _col9, _col14=RS_306._col0, _col1, _col2, _col3, _col5(Inner),Output:["_col4","_col6","_col10","_col11","_col12","_col13","_col19"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_306] - PartitionCols:_col0, _col1, _col2, _col3, _col5 - Select Operator [SEL_304] (rows=1810380 width=485) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_302] (rows=1810380 width=489) - predicate:rank_window_0 is not null - PTF Operator [PTF_300] (rows=1810380 width=489) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4, _col5"}] - Select Operator [SEL_299] (rows=1810380 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_297] - PartitionCols:_col1, _col0, _col4, _col5 - Group By Operator [GBY_296] (rows=1810380 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_93] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_92] (rows=525329897 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col8, _col9, _col5, _col6, _col11, _col12 - Merge Join Operator [MERGEJOIN_276] (rows=525329897 width=483) - Conds:RS_88._col2=RS_295._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col11","_col12"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_295] - PartitionCols:_col0 - Select Operator [SEL_294] (rows=1704 width=183) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_293] (rows=1704 width=183) - predicate:(s_store_sk is not null and s_store_name is not null and s_company_name is not null) - TableScan [TS_79] (rows=1704 width=183) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_275] (rows=525329897 width=308) - Conds:RS_85._col1=RS_292._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_292] - PartitionCols:_col0 - Select Operator [SEL_291] (rows=462000 width=194) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_290] (rows=462000 width=194) - predicate:(i_item_sk is not null and i_category is not null and i_brand is not null) - TableScan [TS_76] (rows=462000 width=194) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_274] (rows=525329897 width=122) - Conds:RS_289._col0=RS_281._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] - PartitionCols:_col0 - Select Operator [SEL_280] (rows=564 width=12) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_279] (rows=564 width=12) - predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1))) and d_date_sk is not null) - TableScan [TS_73] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_289] - PartitionCols:_col0 - Select Operator [SEL_288] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_287] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_70] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_286] - Group By Operator [GBY_285] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] - Group By Operator [GBY_283] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_282] (rows=564 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_280] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col6, _col7, _col8, _col9, _col14 - Merge Join Operator [MERGEJOIN_277] (rows=301730 width=717) - Conds:RS_307._col0, _col1, _col2, _col3, _col5=RS_318._col0, _col1, _col2, _col3, _col8(Inner),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_307] - PartitionCols:_col0, _col1, _col2, _col3, _col5 - Select Operator [SEL_305] (rows=1810380 width=485) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_303] (rows=1810380 width=489) - predicate:rank_window_0 is not null - PTF Operator [PTF_301] (rows=1810380 width=489) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4, _col5"}] - Please refer to the previous Select Operator [SEL_299] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] - PartitionCols:_col0, _col1, _col2, _col3, _col8 - Select Operator [SEL_317] (rows=301730 width=605) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_316] (rows=301730 width=605) - predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col7 - _col0)) / _col0) > 0.1)) ELSE (false) END - Select Operator [SEL_315] (rows=603460 width=601) - Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_314] (rows=603460 width=601) - predicate:((_col0 > 0) and rank_window_1 is not null and (_col3 = 2000)) - PTF Operator [PTF_313] (rows=1810380 width=601) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col3 ASC NULLS LAST, _col4 ASC NULLS LAST","partition by:":"_col2, _col1, _col5, _col6"}] - Select Operator [SEL_312] (rows=1810380 width=601) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_311] - PartitionCols:_col1, _col0, _col4, _col5 - Select Operator [SEL_310] (rows=1810380 width=489) - Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_309] (rows=1810380 width=489) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS FIRST, _col2 ASC NULLS FIRST","partition by:":"_col1, _col0, _col4, _col5, _col2"}] - Select Operator [SEL_308] (rows=1810380 width=489) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_298] - PartitionCols:_col1, _col0, _col4, _col5, _col2 - Please refer to the previous Group By Operator [GBY_296] + Top N Key Operator [TNK_178] (rows=301730 width=546) + keys:(_col12 - _col13), _col11,top n:100 + Merge Join Operator [MERGEJOIN_279] (rows=301730 width=546) + Conds:RS_106._col6, _col7, _col8, _col9, _col14=RS_307._col0, _col1, _col2, _col3, _col5(Inner),Output:["_col4","_col6","_col10","_col11","_col12","_col13","_col19"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_307] + PartitionCols:_col0, _col1, _col2, _col3, _col5 + Select Operator [SEL_305] (rows=1810380 width=485) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_303] (rows=1810380 width=489) + predicate:rank_window_0 is not null + PTF Operator [PTF_301] (rows=1810380 width=489) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4, _col5"}] + Select Operator [SEL_300] (rows=1810380 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_298] + PartitionCols:_col1, _col0, _col4, _col5 + Group By Operator [GBY_297] (rows=1810380 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_93] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_92] (rows=525329897 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col8, _col9, _col5, _col6, _col11, _col12 + Merge Join Operator [MERGEJOIN_277] (rows=525329897 width=483) + Conds:RS_88._col2=RS_296._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col11","_col12"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_296] + PartitionCols:_col0 + Select Operator [SEL_295] (rows=1704 width=183) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_294] (rows=1704 width=183) + predicate:(s_store_sk is not null and s_store_name is not null and s_company_name is not null) + TableScan [TS_79] (rows=1704 width=183) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_276] (rows=525329897 width=308) + Conds:RS_85._col1=RS_293._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_293] + PartitionCols:_col0 + Select Operator [SEL_292] (rows=462000 width=194) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_291] (rows=462000 width=194) + predicate:(i_item_sk is not null and i_category is not null and i_brand is not null) + TableScan [TS_76] (rows=462000 width=194) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_275] (rows=525329897 width=122) + Conds:RS_290._col0=RS_282._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_282] + PartitionCols:_col0 + Select Operator [SEL_281] (rows=564 width=12) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_280] (rows=564 width=12) + predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1))) and d_date_sk is not null) + TableScan [TS_73] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_290] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_288] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_70] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_287] + Group By Operator [GBY_286] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_285] + Group By Operator [GBY_284] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_283] (rows=564 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_281] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_106] + PartitionCols:_col6, _col7, _col8, _col9, _col14 + Merge Join Operator [MERGEJOIN_278] (rows=301730 width=717) + Conds:RS_308._col0, _col1, _col2, _col3, _col5=RS_319._col0, _col1, _col2, _col3, _col8(Inner),Output:["_col4","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_308] + PartitionCols:_col0, _col1, _col2, _col3, _col5 + Select Operator [SEL_306] (rows=1810380 width=485) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_304] (rows=1810380 width=489) + predicate:rank_window_0 is not null + PTF Operator [PTF_302] (rows=1810380 width=489) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4, _col5"}] + Please refer to the previous Select Operator [SEL_300] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_319] + PartitionCols:_col0, _col1, _col2, _col3, _col8 + Select Operator [SEL_318] (rows=301730 width=605) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_317] (rows=301730 width=605) + predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col7 - _col0)) / _col0) > 0.1)) ELSE (false) END + Select Operator [SEL_316] (rows=603460 width=601) + Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_315] (rows=603460 width=601) + predicate:((_col0 > 0) and rank_window_1 is not null and (_col3 = 2000)) + PTF Operator [PTF_314] (rows=1810380 width=601) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col3 ASC NULLS LAST, _col4 ASC NULLS LAST","partition by:":"_col2, _col1, _col5, _col6"}] + Select Operator [SEL_313] (rows=1810380 width=601) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_312] + PartitionCols:_col1, _col0, _col4, _col5 + Select Operator [SEL_311] (rows=1810380 width=489) + Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + PTF Operator [PTF_310] (rows=1810380 width=489) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS FIRST, _col2 ASC NULLS FIRST","partition by:":"_col1, _col0, _col4, _col5, _col2"}] + Select Operator [SEL_309] (rows=1810380 width=489) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_299] + PartitionCols:_col1, _col0, _col4, _col5, _col2 + Please refer to the previous Group By Operator [GBY_297] diff --git ql/src/test/results/clientpositive/perf/tez/query49.q.out ql/src/test/results/clientpositive/perf/tez/query49.q.out index 9c34eccceb..239592bc1d 100644 --- ql/src/test/results/clientpositive/perf/tez/query49.q.out +++ ql/src/test/results/clientpositive/perf/tez/query49.q.out @@ -299,251 +299,251 @@ Stage-0 limit:100 Stage-1 Reducer 11 vectorized - File Output Operator [FS_307] - Limit [LIM_306] (rows=100 width=215) + File Output Operator [FS_312] + Limit [LIM_311] (rows=100 width=215) Number of rows:100 - Select Operator [SEL_305] (rows=40436 width=215) + Select Operator [SEL_310] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_304] - Select Operator [SEL_303] (rows=40436 width=215) + SHUFFLE [RS_309] + Select Operator [SEL_308] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_302] (rows=40436 width=215) + Group By Operator [GBY_307] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 9 [SIMPLE_EDGE] <-Reducer 24 [CONTAINS] vectorized - Reduce Output Operator [RS_348] + Reduce Output Operator [RS_353] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_347] (rows=40436 width=215) + Group By Operator [GBY_352] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Top N Key Operator [TNK_346] (rows=40436 width=214) + Top N Key Operator [TNK_351] (rows=40436 width=214) keys:_col0, _col3, _col4, _col1, _col2,top n:100 - Select Operator [SEL_345] (rows=14232 width=213) + Select Operator [SEL_350] (rows=14232 width=213) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_344] (rows=14232 width=248) + Filter Operator [FIL_349] (rows=14232 width=248) predicate:((_col0 <= 10) or (rank_window_1 <= 10)) - PTF Operator [PTF_343] (rows=21349 width=248) + PTF Operator [PTF_348] (rows=21349 width=248) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col4 AS decimal(15,4)) / CAST( _col5 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_342] (rows=21349 width=248) + Select Operator [SEL_347] (rows=21349 width=248) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_341] + SHUFFLE [RS_346] PartitionCols:0 - Select Operator [SEL_340] (rows=21349 width=244) + Select Operator [SEL_345] (rows=21349 width=244) Output:["rank_window_0","_col0","_col1","_col2","_col3","_col4"] - PTF Operator [PTF_339] (rows=21349 width=244) + PTF Operator [PTF_344] (rows=21349 width=244) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col1 AS decimal(15,4)) / CAST( _col2 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_338] (rows=21349 width=244) + Select Operator [SEL_343] (rows=21349 width=244) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_337] + SHUFFLE [RS_342] PartitionCols:0 - Group By Operator [GBY_336] (rows=21349 width=244) + Group By Operator [GBY_341] (rows=21349 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 21 [SIMPLE_EDGE] SHUFFLE [RS_86] PartitionCols:_col0 Group By Operator [GBY_85] (rows=426980 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)","sum(_col3)","sum(_col9)","sum(_col4)"],keys:_col1 - Merge Join Operator [MERGEJOIN_234] (rows=20856667 width=236) - Conds:RS_81._col1, _col2=RS_335._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col8","_col9"] + Merge Join Operator [MERGEJOIN_239] (rows=20856667 width=236) + Conds:RS_81._col1, _col2=RS_340._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col8","_col9"] <-Map 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_335] + SHUFFLE [RS_340] PartitionCols:_col0, _col1 - Select Operator [SEL_334] (rows=19197050 width=124) + Select Operator [SEL_339] (rows=19197050 width=124) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_333] (rows=19197050 width=119) + Filter Operator [FIL_338] (rows=19197050 width=119) predicate:((sr_return_amt > 10000) and sr_ticket_number is not null and sr_item_sk is not null) TableScan [TS_75] (rows=57591150 width=119) default@store_returns,sr,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_quantity","sr_return_amt"] <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_81] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_233] (rows=61119617 width=124) - Conds:RS_332._col0=RS_269._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_238] (rows=61119617 width=124) + Conds:RS_337._col0=RS_274._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_269] + PARTITION_ONLY_SHUFFLE [RS_274] PartitionCols:_col0 - Select Operator [SEL_264] (rows=50 width=4) + Select Operator [SEL_269] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_263] (rows=50 width=12) + Filter Operator [FIL_268] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 12) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_332] + SHUFFLE [RS_337] PartitionCols:_col0 - Select Operator [SEL_331] (rows=61119617 width=127) + Select Operator [SEL_336] (rows=61119617 width=127) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_330] (rows=61119617 width=229) + Filter Operator [FIL_335] (rows=61119617 width=229) predicate:((ss_net_profit > 1) and (ss_net_paid > 0) and (ss_quantity > 0) and ss_sold_date_sk is not null and ss_ticket_number is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_79_date_dim_d_date_sk_min) AND DynamicValue(RS_79_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_79_date_dim_d_date_sk_bloom_filter))) TableScan [TS_69] (rows=575995635 width=229) default@store_sales,sts,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_net_paid","ss_net_profit"] <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_329] - Group By Operator [GBY_328] (rows=1 width=12) + BROADCAST [RS_334] + Group By Operator [GBY_333] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_276] - Group By Operator [GBY_273] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_281] + Group By Operator [GBY_278] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_270] (rows=50 width=4) + Select Operator [SEL_275] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_264] + Please refer to the previous Select Operator [SEL_269] <-Reducer 8 [CONTAINS] vectorized - Reduce Output Operator [RS_301] + Reduce Output Operator [RS_306] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_300] (rows=40436 width=215) + Group By Operator [GBY_305] (rows=40436 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Top N Key Operator [TNK_299] (rows=40436 width=214) + Top N Key Operator [TNK_304] (rows=40436 width=214) keys:_col0, _col3, _col4, _col1, _col2,top n:100 - Select Operator [SEL_298] (rows=26204 width=215) + Select Operator [SEL_303] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_297] (rows=26204 width=215) + Group By Operator [GBY_302] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 7 [SIMPLE_EDGE] <-Reducer 18 [CONTAINS] vectorized - Reduce Output Operator [RS_327] + Reduce Output Operator [RS_332] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_326] (rows=26204 width=215) + Group By Operator [GBY_331] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Select Operator [SEL_325] (rows=12574 width=215) + Select Operator [SEL_330] (rows=12574 width=215) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_324] (rows=12574 width=248) + Filter Operator [FIL_329] (rows=12574 width=248) predicate:((_col0 <= 10) or (rank_window_1 <= 10)) - PTF Operator [PTF_323] (rows=18863 width=248) + PTF Operator [PTF_328] (rows=18863 width=248) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col4 AS decimal(15,4)) / CAST( _col5 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_322] (rows=18863 width=248) + Select Operator [SEL_327] (rows=18863 width=248) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_321] + SHUFFLE [RS_326] PartitionCols:0 - Select Operator [SEL_320] (rows=18863 width=244) + Select Operator [SEL_325] (rows=18863 width=244) Output:["rank_window_0","_col0","_col1","_col2","_col3","_col4"] - PTF Operator [PTF_319] (rows=18863 width=244) + PTF Operator [PTF_324] (rows=18863 width=244) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col1 AS decimal(15,4)) / CAST( _col2 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_318] (rows=18863 width=244) + Select Operator [SEL_323] (rows=18863 width=244) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_317] + SHUFFLE [RS_322] PartitionCols:0 - Group By Operator [GBY_316] (rows=18863 width=244) + Group By Operator [GBY_321] (rows=18863 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_48] PartitionCols:_col0 Group By Operator [GBY_47] (rows=169767 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)","sum(_col3)","sum(_col9)","sum(_col4)"],keys:_col1 - Merge Join Operator [MERGEJOIN_232] (rows=9599627 width=236) - Conds:RS_43._col1, _col2=RS_315._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col8","_col9"] + Merge Join Operator [MERGEJOIN_237] (rows=9599627 width=236) + Conds:RS_43._col1, _col2=RS_320._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col8","_col9"] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_315] + SHUFFLE [RS_320] PartitionCols:_col0, _col1 - Select Operator [SEL_314] (rows=9599627 width=124) + Select Operator [SEL_319] (rows=9599627 width=124) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_313] (rows=9599627 width=121) + Filter Operator [FIL_318] (rows=9599627 width=121) predicate:((cr_return_amount > 10000) and cr_order_number is not null and cr_item_sk is not null) TableScan [TS_37] (rows=28798881 width=121) default@catalog_returns,cr,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_quantity","cr_return_amount"] <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_43] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_231] (rows=31838858 width=124) - Conds:RS_312._col0=RS_267._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_236] (rows=31838858 width=124) + Conds:RS_317._col0=RS_272._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_267] + PARTITION_ONLY_SHUFFLE [RS_272] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_264] + Please refer to the previous Select Operator [SEL_269] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_312] + SHUFFLE [RS_317] PartitionCols:_col0 - Select Operator [SEL_311] (rows=31838858 width=127) + Select Operator [SEL_316] (rows=31838858 width=127) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_310] (rows=31838858 width=239) + Filter Operator [FIL_315] (rows=31838858 width=239) predicate:((cs_net_profit > 1) and (cs_net_paid > 0) and (cs_quantity > 0) and cs_sold_date_sk is not null and cs_order_number is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_41_date_dim_d_date_sk_min) AND DynamicValue(RS_41_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_41_date_dim_d_date_sk_bloom_filter))) TableScan [TS_31] (rows=287989836 width=239) default@catalog_sales,cs,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_net_paid","cs_net_profit"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_309] - Group By Operator [GBY_308] (rows=1 width=12) + BROADCAST [RS_314] + Group By Operator [GBY_313] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_275] - Group By Operator [GBY_272] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_280] + Group By Operator [GBY_277] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_268] (rows=50 width=4) + Select Operator [SEL_273] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_264] + Please refer to the previous Select Operator [SEL_269] <-Reducer 6 [CONTAINS] vectorized - Reduce Output Operator [RS_296] + Reduce Output Operator [RS_301] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_295] (rows=26204 width=215) + Group By Operator [GBY_300] (rows=26204 width=215) Output:["_col0","_col1","_col2","_col3","_col4"],keys:_col0, _col3, _col4, _col1, _col2 - Select Operator [SEL_294] (rows=13630 width=211) + Select Operator [SEL_299] (rows=13630 width=211) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_293] (rows=13630 width=248) + Filter Operator [FIL_298] (rows=13630 width=248) predicate:((_col0 <= 10) or (rank_window_1 <= 10)) - PTF Operator [PTF_292] (rows=20445 width=248) + PTF Operator [PTF_297] (rows=20445 width=248) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col4 AS decimal(15,4)) / CAST( _col5 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_291] (rows=20445 width=248) + Select Operator [SEL_296] (rows=20445 width=248) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_290] + SHUFFLE [RS_295] PartitionCols:0 - Select Operator [SEL_289] (rows=20445 width=244) + Select Operator [SEL_294] (rows=20445 width=244) Output:["rank_window_0","_col0","_col1","_col2","_col3","_col4"] - PTF Operator [PTF_288] (rows=20445 width=244) + PTF Operator [PTF_293] (rows=20445 width=244) Function definitions:[{},{"name:":"windowingtablefunction","order by:":"(CAST( _col1 AS decimal(15,4)) / CAST( _col2 AS decimal(15,4))) ASC NULLS LAST","partition by:":"0"}] - Select Operator [SEL_287] (rows=20445 width=244) + Select Operator [SEL_292] (rows=20445 width=244) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_286] + SHUFFLE [RS_291] PartitionCols:0 - Group By Operator [GBY_285] (rows=20445 width=244) + Group By Operator [GBY_290] (rows=20445 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 Group By Operator [GBY_16] (rows=102225 width=244) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col8)","sum(_col3)","sum(_col9)","sum(_col4)"],keys:_col1 - Merge Join Operator [MERGEJOIN_230] (rows=5227456 width=236) - Conds:RS_12._col1, _col2=RS_284._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col8","_col9"] + Merge Join Operator [MERGEJOIN_235] (rows=5227456 width=236) + Conds:RS_12._col1, _col2=RS_289._col0, _col1(Inner),Output:["_col1","_col3","_col4","_col8","_col9"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] + SHUFFLE [RS_289] PartitionCols:_col0, _col1 - Select Operator [SEL_283] (rows=4799489 width=124) + Select Operator [SEL_288] (rows=4799489 width=124) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_282] (rows=4799489 width=118) + Filter Operator [FIL_287] (rows=4799489 width=118) predicate:((wr_return_amt > 10000) and wr_order_number is not null and wr_item_sk is not null) TableScan [TS_6] (rows=14398467 width=118) default@web_returns,wr,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_quantity","wr_return_amt"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_229] (rows=15996318 width=124) - Conds:RS_281._col0=RS_265._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_234] (rows=15996318 width=124) + Conds:RS_286._col0=RS_270._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 12 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_265] + PARTITION_ONLY_SHUFFLE [RS_270] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_264] + Please refer to the previous Select Operator [SEL_269] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] + SHUFFLE [RS_286] PartitionCols:_col0 - Select Operator [SEL_280] (rows=15996318 width=127) + Select Operator [SEL_285] (rows=15996318 width=127) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_279] (rows=15996318 width=239) + Filter Operator [FIL_284] (rows=15996318 width=239) predicate:((ws_net_profit > 1) and (ws_net_paid > 0) and (ws_quantity > 0) and ws_sold_date_sk is not null and ws_order_number is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=144002668 width=239) default@web_sales,ws,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_net_paid","ws_net_profit"] <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_278] - Group By Operator [GBY_277] (rows=1 width=12) + BROADCAST [RS_283] + Group By Operator [GBY_282] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_274] - Group By Operator [GBY_271] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_279] + Group By Operator [GBY_276] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_266] (rows=50 width=4) + Select Operator [SEL_271] (rows=50 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_264] + Please refer to the previous Select Operator [SEL_269] diff --git ql/src/test/results/clientpositive/perf/tez/query5.q.out ql/src/test/results/clientpositive/perf/tez/query5.q.out index 38fba27a8e..03980ac2c0 100644 --- ql/src/test/results/clientpositive/perf/tez/query5.q.out +++ ql/src/test/results/clientpositive/perf/tez/query5.q.out @@ -303,235 +303,235 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_304] - Limit [LIM_303] (rows=100 width=619) + File Output Operator [FS_306] + Limit [LIM_305] (rows=100 width=619) Number of rows:100 - Select Operator [SEL_302] (rows=59581 width=619) + Select Operator [SEL_304] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_301] - Select Operator [SEL_300] (rows=59581 width=619) + SHUFFLE [RS_303] + Select Operator [SEL_302] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_299] (rows=59581 width=627) + Group By Operator [GBY_301] (rows=59581 width=627) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 6 [SIMPLE_EDGE] <-Reducer 14 [CONTAINS] vectorized - Reduce Output Operator [RS_315] + Reduce Output Operator [RS_317] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_314] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_313] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_312] (rows=38846 width=619) + Top N Key Operator [TNK_316] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_315] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_314] (rows=38846 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_311] (rows=38846 width=548) + Group By Operator [GBY_313] (rows=38846 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_47] PartitionCols:_col0 Group By Operator [GBY_46] (rows=26026820 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col8 - Merge Join Operator [MERGEJOIN_222] (rows=313339499 width=546) - Conds:RS_42._col0=RS_310._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] + Merge Join Operator [MERGEJOIN_224] (rows=313339499 width=546) + Conds:RS_42._col0=RS_312._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_310] + SHUFFLE [RS_312] PartitionCols:_col0 - Select Operator [SEL_309] (rows=46000 width=104) + Select Operator [SEL_311] (rows=46000 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_308] (rows=46000 width=104) + Filter Operator [FIL_310] (rows=46000 width=104) predicate:cp_catalog_page_sk is not null TableScan [TS_36] (rows=46000 width=104) default@catalog_page,catalog_page,Tbl:COMPLETE,Col:COMPLETE,Output:["cp_catalog_page_sk","cp_catalog_page_id"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_42] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_221] (rows=313339499 width=450) - Conds:Union 22._col1=RS_276._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_223] (rows=313339499 width=450) + Conds:Union 22._col1=RS_278._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_276] + SHUFFLE [RS_278] PartitionCols:_col0 - Select Operator [SEL_273] (rows=8116 width=4) + Select Operator [SEL_275] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_272] (rows=8116 width=98) + Filter Operator [FIL_274] (rows=8116 width=98) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-08-04 00:00:00' AND TIMESTAMP'1998-08-18 00:00:00' and d_date_sk is not null) TableScan [TS_8] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Union 22 [SIMPLE_EDGE] <-Map 21 [CONTAINS] vectorized - Reduce Output Operator [RS_328] + Reduce Output Operator [RS_330] PartitionCols:_col1 - Select Operator [SEL_327] (rows=285117694 width=455) + Select Operator [SEL_329] (rows=285117694 width=455) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_326] (rows=285117694 width=231) + Filter Operator [FIL_328] (rows=285117694 width=231) predicate:(cs_sold_date_sk is not null and cs_catalog_page_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_40_date_dim_d_date_sk_min) AND DynamicValue(RS_40_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_40_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_253] (rows=287989836 width=231) + TableScan [TS_255] (rows=287989836 width=231) Output:["cs_sold_date_sk","cs_catalog_page_sk","cs_ext_sales_price","cs_net_profit"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_325] - Group By Operator [GBY_324] (rows=1 width=12) + BROADCAST [RS_327] + Group By Operator [GBY_326] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] - Group By Operator [GBY_281] (rows=1 width=12) + SHUFFLE [RS_286] + Group By Operator [GBY_283] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_277] (rows=8116 width=4) + Select Operator [SEL_279] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_273] + Please refer to the previous Select Operator [SEL_275] <-Map 23 [CONTAINS] vectorized - Reduce Output Operator [RS_331] + Reduce Output Operator [RS_333] PartitionCols:_col1 - Select Operator [SEL_330] (rows=28221805 width=451) + Select Operator [SEL_332] (rows=28221805 width=451) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_329] (rows=28221805 width=227) + Filter Operator [FIL_331] (rows=28221805 width=227) predicate:(cr_catalog_page_sk is not null and cr_returned_date_sk is not null) - TableScan [TS_258] (rows=28798881 width=227) + TableScan [TS_260] (rows=28798881 width=227) Output:["cr_returned_date_sk","cr_catalog_page_sk","cr_return_amount","cr_net_loss"] <-Reducer 18 [CONTAINS] vectorized - Reduce Output Operator [RS_323] + Reduce Output Operator [RS_325] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_322] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_321] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_320] (rows=53 width=615) + Top N Key Operator [TNK_324] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_323] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_322] (rows=53 width=615) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_319] (rows=53 width=548) + Group By Operator [GBY_321] (rows=53 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 17 [SIMPLE_EDGE] SHUFFLE [RS_80] PartitionCols:_col0 Group By Operator [GBY_79] (rows=31641 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col8 - Merge Join Operator [MERGEJOIN_224] (rows=278713608 width=547) - Conds:RS_75._col0=RS_318._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] + Merge Join Operator [MERGEJOIN_226] (rows=278713608 width=547) + Conds:RS_75._col0=RS_320._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] <-Map 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] + SHUFFLE [RS_320] PartitionCols:_col0 - Select Operator [SEL_317] (rows=84 width=104) + Select Operator [SEL_319] (rows=84 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_316] (rows=84 width=104) + Filter Operator [FIL_318] (rows=84 width=104) predicate:web_site_sk is not null TableScan [TS_69] (rows=84 width=104) default@web_site,web_site,Tbl:COMPLETE,Col:COMPLETE,Output:["web_site_sk","web_site_id"] <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_75] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_223] (rows=278713608 width=451) - Conds:Union 26._col1=RS_278._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_225] (rows=278713608 width=451) + Conds:Union 26._col1=RS_280._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_278] + SHUFFLE [RS_280] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_273] + Please refer to the previous Select Operator [SEL_275] <-Union 26 [SIMPLE_EDGE] <-Map 25 [CONTAINS] vectorized - Reduce Output Operator [RS_336] + Reduce Output Operator [RS_338] PartitionCols:_col1 - Select Operator [SEL_335] (rows=143930874 width=455) + Select Operator [SEL_337] (rows=143930874 width=455) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_334] (rows=143930874 width=231) + Filter Operator [FIL_336] (rows=143930874 width=231) predicate:(ws_web_site_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_73_date_dim_d_date_sk_min) AND DynamicValue(RS_73_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_73_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_263] (rows=144002668 width=231) + TableScan [TS_265] (rows=144002668 width=231) Output:["ws_sold_date_sk","ws_web_site_sk","ws_ext_sales_price","ws_net_profit"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_333] - Group By Operator [GBY_332] (rows=1 width=12) + BROADCAST [RS_335] + Group By Operator [GBY_334] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_285] - Group By Operator [GBY_282] (rows=1 width=12) + SHUFFLE [RS_287] + Group By Operator [GBY_284] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_279] (rows=8116 width=4) + Select Operator [SEL_281] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_273] + Please refer to the previous Select Operator [SEL_275] <-Reducer 28 [CONTAINS] - Reduce Output Operator [RS_271] + Reduce Output Operator [RS_273] PartitionCols:_col1 - Select Operator [SEL_269] (rows=134782734 width=454) + Select Operator [SEL_271] (rows=134782734 width=454) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_268] (rows=134782734 width=230) - Conds:RS_339._col0, _col2=RS_342._col1, _col2(Inner),Output:["_col1","_col3","_col6","_col7"] + Merge Join Operator [MERGEJOIN_270] (rows=134782734 width=230) + Conds:RS_341._col0, _col2=RS_344._col1, _col2(Inner),Output:["_col1","_col3","_col6","_col7"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_339] + SHUFFLE [RS_341] PartitionCols:_col0, _col2 - Select Operator [SEL_338] (rows=143966669 width=11) + Select Operator [SEL_340] (rows=143966669 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_337] (rows=143966669 width=11) + Filter Operator [FIL_339] (rows=143966669 width=11) predicate:(ws_web_site_sk is not null and ws_item_sk is not null and ws_order_number is not null) TableScan [TS_54] (rows=144002668 width=11) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_item_sk","ws_web_site_sk","ws_order_number"] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_342] + SHUFFLE [RS_344] PartitionCols:_col1, _col2 - Select Operator [SEL_341] (rows=13749816 width=225) + Select Operator [SEL_343] (rows=13749816 width=225) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_340] (rows=13749816 width=225) + Filter Operator [FIL_342] (rows=13749816 width=225) predicate:(wr_returned_date_sk is not null and wr_item_sk is not null and wr_order_number is not null) TableScan [TS_57] (rows=14398467 width=225) default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_item_sk","wr_order_number","wr_return_amt","wr_net_loss"] <-Reducer 5 [CONTAINS] vectorized - Reduce Output Operator [RS_298] + Reduce Output Operator [RS_300] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_297] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_296] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_295] (rows=822 width=617) + Top N Key Operator [TNK_299] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_298] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_297] (rows=822 width=617) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_294] (rows=822 width=548) + Group By Operator [GBY_296] (rows=822 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)"],keys:KEY._col0 <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_22] PartitionCols:_col0 Group By Operator [GBY_21] (rows=983934 width=548) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col2)","sum(_col4)","sum(_col3)","sum(_col5)"],keys:_col8 - Merge Join Operator [MERGEJOIN_220] (rows=578964757 width=528) - Conds:RS_17._col0=RS_293._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] + Merge Join Operator [MERGEJOIN_222] (rows=578964757 width=528) + Conds:RS_17._col0=RS_295._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_293] + SHUFFLE [RS_295] PartitionCols:_col0 - Select Operator [SEL_292] (rows=1704 width=104) + Select Operator [SEL_294] (rows=1704 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_291] (rows=1704 width=104) + Filter Operator [FIL_293] (rows=1704 width=104) predicate:s_store_sk is not null TableScan [TS_11] (rows=1704 width=104) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_219] (rows=578964757 width=432) - Conds:Union 2._col1=RS_274._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_221] (rows=578964757 width=432) + Conds:Union 2._col1=RS_276._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_274] + SHUFFLE [RS_276] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_273] + Please refer to the previous Select Operator [SEL_275] <-Union 2 [SIMPLE_EDGE] <-Map 1 [CONTAINS] vectorized - Reduce Output Operator [RS_290] + Reduce Output Operator [RS_292] PartitionCols:_col1 - Select Operator [SEL_289] (rows=525329897 width=445) + Select Operator [SEL_291] (rows=525329897 width=445) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_288] (rows=525329897 width=221) + Filter Operator [FIL_290] (rows=525329897 width=221) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_15_date_dim_d_date_sk_min) AND DynamicValue(RS_15_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_15_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_225] (rows=575995635 width=221) + TableScan [TS_227] (rows=575995635 width=221) Output:["ss_sold_date_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_287] - Group By Operator [GBY_286] (rows=1 width=12) + BROADCAST [RS_289] + Group By Operator [GBY_288] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_283] - Group By Operator [GBY_280] (rows=1 width=12) + SHUFFLE [RS_285] + Group By Operator [GBY_282] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_275] (rows=8116 width=4) + Select Operator [SEL_277] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_273] + Please refer to the previous Select Operator [SEL_275] <-Map 9 [CONTAINS] vectorized - Reduce Output Operator [RS_307] + Reduce Output Operator [RS_309] PartitionCols:_col1 - Select Operator [SEL_306] (rows=53634860 width=447) + Select Operator [SEL_308] (rows=53634860 width=447) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_305] (rows=53634860 width=223) + Filter Operator [FIL_307] (rows=53634860 width=223) predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) - TableScan [TS_236] (rows=57591150 width=223) + TableScan [TS_238] (rows=57591150 width=223) Output:["sr_returned_date_sk","sr_store_sk","sr_return_amt","sr_net_loss"] diff --git ql/src/test/results/clientpositive/perf/tez/query50.q.out ql/src/test/results/clientpositive/perf/tez/query50.q.out index 6e34831de6..3d9cbbde63 100644 --- ql/src/test/results/clientpositive/perf/tez/query50.q.out +++ ql/src/test/results/clientpositive/perf/tez/query50.q.out @@ -139,83 +139,83 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_140] - Limit [LIM_139] (rows=100 width=858) + File Output Operator [FS_145] + Limit [LIM_144] (rows=100 width=858) Number of rows:100 - Select Operator [SEL_138] (rows=478292911 width=857) + Select Operator [SEL_143] (rows=478292911 width=857) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_137] - Group By Operator [GBY_136] (rows=478292911 width=857) + SHUFFLE [RS_142] + Group By Operator [GBY_141] (rows=478292911 width=857) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, KEY._col8, KEY._col9 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 Group By Operator [GBY_29] (rows=478292911 width=857) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"],aggregations:["sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)"],keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9 - Top N Key Operator [TNK_56] (rows=478292911 width=825) - keys:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9,top n:100 - Select Operator [SEL_27] (rows=478292911 width=825) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] - Merge Join Operator [MERGEJOIN_120] (rows=478292911 width=825) - Conds:RS_24._col8=RS_135._col0(Inner),Output:["_col0","_col5","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21"] + Select Operator [SEL_27] (rows=478292911 width=825) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] + Top N Key Operator [TNK_59] (rows=478292911 width=825) + keys:_col12, _col13, _col14, _col15, _col16, _col17, _col18, _col19, _col20, _col21,top n:100 + Merge Join Operator [MERGEJOIN_125] (rows=478292911 width=825) + Conds:RS_24._col8=RS_140._col0(Inner),Output:["_col0","_col5","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_135] + SHUFFLE [RS_140] PartitionCols:_col0 - Select Operator [SEL_134] (rows=1704 width=821) + Select Operator [SEL_139] (rows=1704 width=821) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - Filter Operator [FIL_133] (rows=1704 width=821) + Filter Operator [FIL_138] (rows=1704 width=821) predicate:s_store_sk is not null TableScan [TS_12] (rows=1704 width=821) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_id","s_street_number","s_street_name","s_street_type","s_suite_number","s_city","s_county","s_state","s_zip"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col8 - Merge Join Operator [MERGEJOIN_119] (rows=478292911 width=11) - Conds:RS_21._col5=RS_132._col0(Inner),Output:["_col0","_col5","_col8"] + Merge Join Operator [MERGEJOIN_124] (rows=478292911 width=11) + Conds:RS_21._col5=RS_137._col0(Inner),Output:["_col0","_col5","_col8"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_132] + SHUFFLE [RS_137] PartitionCols:_col0 - Select Operator [SEL_131] (rows=73049 width=4) + Select Operator [SEL_136] (rows=73049 width=4) Output:["_col0"] - Filter Operator [FIL_130] (rows=73049 width=4) + Filter Operator [FIL_135] (rows=73049 width=4) predicate:d_date_sk is not null TableScan [TS_9] (rows=73049 width=4) default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col5 - Merge Join Operator [MERGEJOIN_118] (rows=478292911 width=11) - Conds:RS_18._col1, _col2, _col3=RS_129._col1, _col2, _col4(Inner),Output:["_col0","_col5","_col8"] + Merge Join Operator [MERGEJOIN_123] (rows=478292911 width=11) + Conds:RS_18._col1, _col2, _col3=RS_134._col1, _col2, _col4(Inner),Output:["_col0","_col5","_col8"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_129] + SHUFFLE [RS_134] PartitionCols:_col1, _col2, _col4 - Select Operator [SEL_128] (rows=501694138 width=19) + Select Operator [SEL_133] (rows=501694138 width=19) Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_127] (rows=501694138 width=19) + Filter Operator [FIL_132] (rows=501694138 width=19) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_store_sk is not null and ss_ticket_number is not null and ss_item_sk is not null) TableScan [TS_6] (rows=575995635 width=19) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_store_sk","ss_ticket_number"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col1, _col2, _col3 - Merge Join Operator [MERGEJOIN_117] (rows=53632139 width=15) - Conds:RS_123._col0=RS_126._col0(Inner),Output:["_col0","_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_122] (rows=53632139 width=15) + Conds:RS_128._col0=RS_131._col0(Inner),Output:["_col0","_col1","_col2","_col3"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_123] + SHUFFLE [RS_128] PartitionCols:_col0 - Select Operator [SEL_122] (rows=53632139 width=15) + Select Operator [SEL_127] (rows=53632139 width=15) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_121] (rows=53632139 width=15) + Filter Operator [FIL_126] (rows=53632139 width=15) predicate:(sr_customer_sk is not null and sr_returned_date_sk is not null and sr_ticket_number is not null and sr_item_sk is not null) TableScan [TS_0] (rows=57591150 width=15) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_customer_sk","sr_ticket_number"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_126] + SHUFFLE [RS_131] PartitionCols:_col0 - Select Operator [SEL_125] (rows=50 width=4) + Select Operator [SEL_130] (rows=50 width=4) Output:["_col0"] - Filter Operator [FIL_124] (rows=50 width=12) + Filter Operator [FIL_129] (rows=50 width=12) predicate:((d_year = 2000) and (d_moy = 9) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=12) default@date_dim,d2,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] diff --git ql/src/test/results/clientpositive/perf/tez/query51.q.out ql/src/test/results/clientpositive/perf/tez/query51.q.out index 906d702207..5dc11619a4 100644 --- ql/src/test/results/clientpositive/perf/tez/query51.q.out +++ ql/src/test/results/clientpositive/perf/tez/query51.q.out @@ -114,109 +114,111 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_117] - Limit [LIM_116] (rows=100 width=636) + File Output Operator [FS_119] + Limit [LIM_118] (rows=100 width=636) Number of rows:100 - Select Operator [SEL_115] (rows=2095597606 width=636) + Select Operator [SEL_117] (rows=2095597606 width=636) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_114] - Select Operator [SEL_113] (rows=2095597606 width=636) + SHUFFLE [RS_116] + Select Operator [SEL_115] (rows=2095597606 width=636) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_112] (rows=2095597606 width=420) - predicate:(max_window_0 > max_window_1) - PTF Operator [PTF_111] (rows=6286792818 width=420) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"CASE WHEN (_col4 is not null) THEN (_col4) ELSE (_col1) END ASC NULLS LAST","partition by:":"CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END"}] - Select Operator [SEL_110] (rows=6286792818 width=420) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_43] - PartitionCols:CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END - Merge Join Operator [MERGEJOIN_87] (rows=6286792818 width=420) - Conds:RS_40._col0, _col1=RS_41._col0, _col1(Outer),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_41] - PartitionCols:_col0, _col1 - Select Operator [SEL_37] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"] - PTF Operator [PTF_36] (rows=19832154 width=210) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] - Group By Operator [GBY_32] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_31] - PartitionCols:_col0 - Group By Operator [GBY_30] (rows=143966864 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 - Merge Join Operator [MERGEJOIN_86] (rows=143966864 width=209) - Conds:RS_108._col0=RS_92._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_92] - PartitionCols:_col0 - Select Operator [SEL_89] (rows=317 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_88] (rows=317 width=102) - predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=102) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_month_seq"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_108] - PartitionCols:_col0 - Select Operator [SEL_107] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_106] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_27_date_dim_d_date_sk_min) AND DynamicValue(RS_27_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_27_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_sales_price"] - <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_105] - Group By Operator [GBY_104] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - Group By Operator [GBY_95] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_93] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_89] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col0, _col1 - Select Operator [SEL_17] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"] - PTF Operator [PTF_16] (rows=19832154 width=210) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] - Group By Operator [GBY_12] (rows=19832154 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col0 - Group By Operator [GBY_10] (rows=550076554 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 - Merge Join Operator [MERGEJOIN_85] (rows=550076554 width=204) - Conds:RS_102._col0=RS_90._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_90] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_89] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_102] - PartitionCols:_col0 - Select Operator [SEL_101] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_100] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_99] - Group By Operator [GBY_98] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] - Group By Operator [GBY_94] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_91] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_89] + Top N Key Operator [TNK_114] (rows=2095597606 width=420) + keys:CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END, CASE WHEN (_col4 is not null) THEN (_col4) ELSE (_col1) END,top n:100 + Filter Operator [FIL_113] (rows=2095597606 width=420) + predicate:(max_window_0 > max_window_1) + PTF Operator [PTF_112] (rows=6286792818 width=420) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"CASE WHEN (_col4 is not null) THEN (_col4) ELSE (_col1) END ASC NULLS LAST","partition by:":"CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END"}] + Select Operator [SEL_111] (rows=6286792818 width=420) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:CASE WHEN (_col3 is not null) THEN (_col3) ELSE (_col0) END + Merge Join Operator [MERGEJOIN_88] (rows=6286792818 width=420) + Conds:RS_40._col0, _col1=RS_41._col0, _col1(Outer),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_41] + PartitionCols:_col0, _col1 + Select Operator [SEL_37] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"] + PTF Operator [PTF_36] (rows=19832154 width=210) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] + Group By Operator [GBY_32] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_31] + PartitionCols:_col0 + Group By Operator [GBY_30] (rows=143966864 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 + Merge Join Operator [MERGEJOIN_87] (rows=143966864 width=209) + Conds:RS_109._col0=RS_93._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_93] + PartitionCols:_col0 + Select Operator [SEL_90] (rows=317 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_89] (rows=317 width=102) + predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=102) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_month_seq"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_109] + PartitionCols:_col0 + Select Operator [SEL_108] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_107] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_27_date_dim_d_date_sk_min) AND DynamicValue(RS_27_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_27_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_sales_price"] + <-Reducer 11 [BROADCAST_EDGE] vectorized + BROADCAST [RS_106] + Group By Operator [GBY_105] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_98] + Group By Operator [GBY_96] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_94] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_90] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col0, _col1 + Select Operator [SEL_17] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"] + PTF Operator [PTF_16] (rows=19832154 width=210) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS LAST","partition by:":"_col0"}] + Group By Operator [GBY_12] (rows=19832154 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col0 + Group By Operator [GBY_10] (rows=550076554 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col1, _col4 + Merge Join Operator [MERGEJOIN_86] (rows=550076554 width=204) + Conds:RS_103._col0=RS_91._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_91] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_90] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_103] + PartitionCols:_col0 + Select Operator [SEL_102] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_101] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_100] + Group By Operator [GBY_99] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_97] + Group By Operator [GBY_95] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_92] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_90] diff --git ql/src/test/results/clientpositive/perf/tez/query52.q.out ql/src/test/results/clientpositive/perf/tez/query52.q.out index b579d5fbff..d96401a4c2 100644 --- ql/src/test/results/clientpositive/perf/tez/query52.q.out +++ ql/src/test/results/clientpositive/perf/tez/query52.q.out @@ -63,65 +63,67 @@ Stage-0 limit:-1 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Select Operator [SEL_73] (rows=100 width=220) + File Output Operator [FS_76] + Select Operator [SEL_75] (rows=100 width=220) Output:["_col0","_col1","_col2","_col3"] - Limit [LIM_72] (rows=100 width=216) + Limit [LIM_74] (rows=100 width=216) Number of rows:100 - Select Operator [SEL_71] (rows=7333 width=216) + Select Operator [SEL_73] (rows=7333 width=216) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_70] - Group By Operator [GBY_69] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1 - Group By Operator [GBY_16] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 - Merge Join Operator [MERGEJOIN_54] (rows=84037218 width=183) - Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_68] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=7333 width=107) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_66] (rows=7333 width=111) - predicate:((i_manager_id = 1) and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=111) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_53] (rows=550076554 width=110) - Conds:RS_65._col0=RS_57._col0(Inner),Output:["_col1","_col2"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_57] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_55] (rows=50 width=12) - predicate:((d_year = 1998) and (d_moy = 12) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_63] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_62] - Group By Operator [GBY_61] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_60] - Group By Operator [GBY_59] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_58] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_56] + SHUFFLE [RS_72] + Top N Key Operator [TNK_71] (rows=7333 width=216) + keys:_col2, _col0,top n:100 + Group By Operator [GBY_70] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1 + Group By Operator [GBY_16] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 + Merge Join Operator [MERGEJOIN_55] (rows=84037218 width=183) + Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] + PartitionCols:_col0 + Select Operator [SEL_68] (rows=7333 width=107) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_67] (rows=7333 width=111) + predicate:((i_manager_id = 1) and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=111) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_54] (rows=550076554 width=110) + Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_56] (rows=50 width=12) + predicate:((d_year = 1998) and (d_moy = 12) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,dt,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_dt_d_date_sk_min) AND DynamicValue(RS_10_dt_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_dt_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/query53.q.out ql/src/test/results/clientpositive/perf/tez/query53.q.out index 1bee5e099c..13ab294cde 100644 --- ql/src/test/results/clientpositive/perf/tez/query53.q.out +++ ql/src/test/results/clientpositive/perf/tez/query53.q.out @@ -78,87 +78,89 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_106] - Limit [LIM_105] (rows=100 width=228) + File Output Operator [FS_107] + Limit [LIM_106] (rows=100 width=228) Number of rows:100 - Select Operator [SEL_104] (rows=130 width=228) + Select Operator [SEL_105] (rows=130 width=228) Output:["_col0","_col1","_col2"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_33] Select Operator [SEL_30] (rows=130 width=228) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_46] (rows=130 width=228) - predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END - Select Operator [SEL_29] (rows=260 width=116) - Output:["avg_window_0","_col0","_col2"] - PTF Operator [PTF_28] (rows=260 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] - Select Operator [SEL_25] (rows=260 width=116) - Output:["_col0","_col2"] - Group By Operator [GBY_24] (rows=260 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0 - Group By Operator [GBY_22] (rows=260 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col5, _col7 - Merge Join Operator [MERGEJOIN_84] (rows=569118 width=8) - Conds:RS_18._col2=RS_101._col0(Inner),Output:["_col3","_col5","_col7"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_101] - PartitionCols:_col0 - Select Operator [SEL_100] (rows=1704 width=4) - Output:["_col0"] - Filter Operator [FIL_99] (rows=1704 width=4) - predicate:s_store_sk is not null - TableScan [TS_9] (rows=1704 width=4) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_83] (rows=569118 width=8) - Conds:RS_15._col0=RS_98._col0(Inner),Output:["_col2","_col3","_col5","_col7"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_98] - PartitionCols:_col0 - Select Operator [SEL_97] (rows=317 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_96] (rows=317 width=12) - predicate:((d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_qoy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_82] (rows=569118 width=4) - Conds:RS_95._col1=RS_87._col0(Inner),Output:["_col0","_col2","_col3","_col5"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_87] - PartitionCols:_col0 - Select Operator [SEL_86] (rows=52 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_85] (rows=52 width=290) - predicate:((i_class) IN ('personal', 'portable', 'reference', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'reference', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1'))) and i_item_sk is not null) - TableScan [TS_3] (rows=462000 width=289) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manufact_id"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_95] - PartitionCols:_col1 - Select Operator [SEL_94] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_93] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_13_item_i_item_sk_min) AND DynamicValue(RS_13_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_13_item_i_item_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_92] - Group By Operator [GBY_91] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_90] - Group By Operator [GBY_89] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_88] (rows=52 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_86] + Top N Key Operator [TNK_52] (rows=130 width=228) + keys:avg_window_0, _col2, _col0,top n:100 + Filter Operator [FIL_46] (rows=130 width=228) + predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END + Select Operator [SEL_29] (rows=260 width=116) + Output:["avg_window_0","_col0","_col2"] + PTF Operator [PTF_28] (rows=260 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] + Select Operator [SEL_25] (rows=260 width=116) + Output:["_col0","_col2"] + Group By Operator [GBY_24] (rows=260 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0 + Group By Operator [GBY_22] (rows=260 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col5, _col7 + Merge Join Operator [MERGEJOIN_85] (rows=569118 width=8) + Conds:RS_18._col2=RS_102._col0(Inner),Output:["_col3","_col5","_col7"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_102] + PartitionCols:_col0 + Select Operator [SEL_101] (rows=1704 width=4) + Output:["_col0"] + Filter Operator [FIL_100] (rows=1704 width=4) + predicate:s_store_sk is not null + TableScan [TS_9] (rows=1704 width=4) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_84] (rows=569118 width=8) + Conds:RS_15._col0=RS_99._col0(Inner),Output:["_col2","_col3","_col5","_col7"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_99] + PartitionCols:_col0 + Select Operator [SEL_98] (rows=317 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_97] (rows=317 width=12) + predicate:((d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_qoy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_83] (rows=569118 width=4) + Conds:RS_96._col1=RS_88._col0(Inner),Output:["_col0","_col2","_col3","_col5"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_88] + PartitionCols:_col0 + Select Operator [SEL_87] (rows=52 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_86] (rows=52 width=290) + predicate:((i_class) IN ('personal', 'portable', 'reference', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'reference', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1'))) and i_item_sk is not null) + TableScan [TS_3] (rows=462000 width=289) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manufact_id"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_96] + PartitionCols:_col1 + Select Operator [SEL_95] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_94] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_13_item_i_item_sk_min) AND DynamicValue(RS_13_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_13_item_i_item_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_93] + Group By Operator [GBY_92] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_91] + Group By Operator [GBY_90] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_89] (rows=52 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_87] diff --git ql/src/test/results/clientpositive/perf/tez/query54.q.out ql/src/test/results/clientpositive/perf/tez/query54.q.out index a19bd171e5..4432a31fe2 100644 --- ql/src/test/results/clientpositive/perf/tez/query54.q.out +++ ql/src/test/results/clientpositive/perf/tez/query54.q.out @@ -1,7 +1,7 @@ -Warning: Shuffle Join MERGEJOIN[269][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product -Warning: Shuffle Join MERGEJOIN[270][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4]] in Stage 'Reducer 5' is a cross product -Warning: Shuffle Join MERGEJOIN[271][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 6' is a cross product -Warning: Shuffle Join MERGEJOIN[272][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 7' is a cross product +Warning: Shuffle Join MERGEJOIN[271][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3]] in Stage 'Reducer 4' is a cross product +Warning: Shuffle Join MERGEJOIN[272][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4]] in Stage 'Reducer 5' is a cross product +Warning: Shuffle Join MERGEJOIN[273][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5]] in Stage 'Reducer 6' is a cross product +Warning: Shuffle Join MERGEJOIN[274][tables = [$hdt$_0, $hdt$_1, $hdt$_2, $hdt$_3, $hdt$_4, $hdt$_5, $hdt$_6]] in Stage 'Reducer 7' is a cross product PREHOOK: query: explain with my_customers as ( select distinct c_customer_sk @@ -163,263 +163,267 @@ Stage-0 limit:100 Stage-1 Reducer 10 vectorized - File Output Operator [FS_354] - Limit [LIM_353] (rows=100 width=16) + File Output Operator [FS_358] + Limit [LIM_357] (rows=100 width=16) Number of rows:100 - Select Operator [SEL_352] (rows=338 width=16) + Select Operator [SEL_356] (rows=338 width=16) Output:["_col0","_col1","_col2"] <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_351] - Select Operator [SEL_350] (rows=338 width=16) + SHUFFLE [RS_355] + Select Operator [SEL_354] (rows=338 width=16) Output:["_col0","_col1","_col2"] - Group By Operator [GBY_349] (rows=338 width=12) - Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Group By Operator [GBY_347] (rows=338 width=12) - Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 - Select Operator [SEL_346] (rows=676 width=116) - Output:["_col0"] - Group By Operator [GBY_345] (rows=676 width=116) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_118] - PartitionCols:_col0 - Group By Operator [GBY_117] (rows=11944920 width=116) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col10 - Select Operator [SEL_116] (rows=36481068608 width=123) - Output:["_col2","_col10"] - Filter Operator [FIL_115] (rows=36481068608 width=123) - predicate:(_col4 <= _col15) - Merge Join Operator [MERGEJOIN_272] (rows=109443205825 width=123) - Conds:(Inner),Output:["_col2","_col4","_col10","_col15"] - <-Reducer 33 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_344] - Group By Operator [GBY_343] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_324] - PartitionCols:_col0 - Group By Operator [GBY_320] (rows=25 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_316] (rows=50 width=12) - Output:["_col0"] - Filter Operator [FIL_312] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) - TableScan [TS_50] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] - <-Reducer 6 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_112] - Filter Operator [FIL_111] (rows=4377728233 width=123) - predicate:(_col14 <= _col4) - Merge Join Operator [MERGEJOIN_271] (rows=13133184700 width=123) - Conds:(Inner),Output:["_col2","_col4","_col10","_col14"] - <-Reducer 32 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_342] - Group By Operator [GBY_341] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Group By Operator [GBY_319] (rows=25 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_315] (rows=50 width=12) - Output:["_col0"] - Filter Operator [FIL_311] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) - Please refer to the previous TableScan [TS_50] - <-Reducer 5 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_108] - Merge Join Operator [MERGEJOIN_270] (rows=525327388 width=114) - Conds:(Inner),Output:["_col2","_col4","_col10"] - <-Reducer 31 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_340] - Select Operator [SEL_339] (rows=1 width=8) - Filter Operator [FIL_338] (rows=1 width=8) - predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_337] (rows=1 width=8) - Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Reducer 30 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_336] - Group By Operator [GBY_335] (rows=1 width=8) - Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_334] (rows=25 width=4) - Group By Operator [GBY_333] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_322] - PartitionCols:_col0 - Group By Operator [GBY_318] (rows=25 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_314] (rows=50 width=12) - Output:["_col0"] - Filter Operator [FIL_310] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3)) - Please refer to the previous TableScan [TS_50] - <-Reducer 4 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_105] - Merge Join Operator [MERGEJOIN_269] (rows=525327388 width=114) + Top N Key Operator [TNK_353] (rows=338 width=12) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_352] (rows=338 width=12) + Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 + Top N Key Operator [TNK_351] (rows=338 width=12) + keys:KEY._col0,top n:100 + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_350] + PartitionCols:_col0 + Group By Operator [GBY_349] (rows=338 width=12) + Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 + Select Operator [SEL_348] (rows=676 width=116) + Output:["_col0"] + Group By Operator [GBY_347] (rows=676 width=116) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_118] + PartitionCols:_col0 + Group By Operator [GBY_117] (rows=11944920 width=116) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col10 + Select Operator [SEL_116] (rows=36481068608 width=123) + Output:["_col2","_col10"] + Filter Operator [FIL_115] (rows=36481068608 width=123) + predicate:(_col4 <= _col15) + Merge Join Operator [MERGEJOIN_274] (rows=109443205825 width=123) + Conds:(Inner),Output:["_col2","_col4","_col10","_col15"] + <-Reducer 33 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_346] + Group By Operator [GBY_345] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_326] + PartitionCols:_col0 + Group By Operator [GBY_322] (rows=25 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_318] (rows=50 width=12) + Output:["_col0"] + Filter Operator [FIL_314] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) + TableScan [TS_50] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] + <-Reducer 6 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_112] + Filter Operator [FIL_111] (rows=4377728233 width=123) + predicate:(_col14 <= _col4) + Merge Join Operator [MERGEJOIN_273] (rows=13133184700 width=123) + Conds:(Inner),Output:["_col2","_col4","_col10","_col14"] + <-Reducer 32 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_344] + Group By Operator [GBY_343] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_325] + PartitionCols:_col0 + Group By Operator [GBY_321] (rows=25 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_317] (rows=50 width=12) + Output:["_col0"] + Filter Operator [FIL_313] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3) and d_month_seq is not null) + Please refer to the previous TableScan [TS_50] + <-Reducer 5 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_108] + Merge Join Operator [MERGEJOIN_272] (rows=525327388 width=114) Conds:(Inner),Output:["_col2","_col4","_col10"] - <-Reducer 29 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_332] - Select Operator [SEL_331] (rows=1 width=8) - Filter Operator [FIL_330] (rows=1 width=8) + <-Reducer 31 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_342] + Select Operator [SEL_341] (rows=1 width=8) + Filter Operator [FIL_340] (rows=1 width=8) predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_329] (rows=1 width=8) + Group By Operator [GBY_339] (rows=1 width=8) Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Reducer 28 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_328] - Group By Operator [GBY_327] (rows=1 width=8) + <-Reducer 30 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_338] + Group By Operator [GBY_337] (rows=1 width=8) Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_326] (rows=25 width=4) - Group By Operator [GBY_325] (rows=25 width=4) + Select Operator [SEL_336] (rows=25 width=4) + Group By Operator [GBY_335] (rows=25 width=4) Output:["_col0"],keys:KEY._col0 <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_321] + SHUFFLE [RS_324] PartitionCols:_col0 - Group By Operator [GBY_317] (rows=25 width=4) + Group By Operator [GBY_320] (rows=25 width=4) Output:["_col0"],keys:_col0 - Select Operator [SEL_313] (rows=50 width=12) + Select Operator [SEL_316] (rows=50 width=12) Output:["_col0"] - Please refer to the previous Filter Operator [FIL_310] - <-Reducer 3 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_102] - Merge Join Operator [MERGEJOIN_268] (rows=525327388 width=114) - Conds:RS_99._col1=RS_100._col5(Inner),Output:["_col2","_col4","_col10"] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_100] - PartitionCols:_col5 - Merge Join Operator [MERGEJOIN_267] (rows=4049224 width=4) - Conds:RS_46._col0=RS_309._col1(Inner),Output:["_col5"] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_46] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_263] (rows=39720279 width=4) - Conds:RS_291._col1, _col2=RS_294._col0, _col1(Inner),Output:["_col0"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_291] - PartitionCols:_col1, _col2 - Select Operator [SEL_290] (rows=40000000 width=188) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_289] (rows=40000000 width=188) - predicate:(ca_address_sk is not null and ca_county is not null and ca_state is not null) - TableScan [TS_6] (rows=40000000 width=188) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_294] - PartitionCols:_col0, _col1 - Select Operator [SEL_293] (rows=1704 width=184) - Output:["_col0","_col1"] - Filter Operator [FIL_292] (rows=1704 width=184) - predicate:(s_county is not null and s_state is not null) - TableScan [TS_9] (rows=1704 width=184) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"] - <-Reducer 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_309] - PartitionCols:_col1 - Select Operator [SEL_308] (rows=4049224 width=8) - Output:["_col0","_col1"] - Group By Operator [GBY_307] (rows=4049224 width=8) - Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col0, _col1 - Group By Operator [GBY_39] (rows=4049224 width=8) - Output:["_col0","_col1"],keys:_col6, _col5 - Merge Join Operator [MERGEJOIN_266] (rows=4049224 width=8) - Conds:RS_35._col1=RS_306._col0(Inner),Output:["_col5","_col6"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_306] + Filter Operator [FIL_312] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3)) + Please refer to the previous TableScan [TS_50] + <-Reducer 4 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_105] + Merge Join Operator [MERGEJOIN_271] (rows=525327388 width=114) + Conds:(Inner),Output:["_col2","_col4","_col10"] + <-Reducer 29 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_334] + Select Operator [SEL_333] (rows=1 width=8) + Filter Operator [FIL_332] (rows=1 width=8) + predicate:(sq_count_check(_col0) <= 1) + Group By Operator [GBY_331] (rows=1 width=8) + Output:["_col0"],aggregations:["count(VALUE._col0)"] + <-Reducer 28 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_330] + Group By Operator [GBY_329] (rows=1 width=8) + Output:["_col0"],aggregations:["count()"] + Select Operator [SEL_328] (rows=25 width=4) + Group By Operator [GBY_327] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_323] PartitionCols:_col0 - Select Operator [SEL_305] (rows=80000000 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_304] (rows=80000000 width=8) - predicate:(c_customer_sk is not null and c_current_addr_sk is not null) - TableScan [TS_26] (rows=80000000 width=8) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_265] (rows=4049224 width=1) - Conds:RS_32._col2=RS_303._col0(Inner),Output:["_col1"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_303] + Group By Operator [GBY_319] (rows=25 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_315] (rows=50 width=12) + Output:["_col0"] + Please refer to the previous Filter Operator [FIL_312] + <-Reducer 3 [CUSTOM_SIMPLE_EDGE] + PARTITION_ONLY_SHUFFLE [RS_102] + Merge Join Operator [MERGEJOIN_270] (rows=525327388 width=114) + Conds:RS_99._col1=RS_100._col5(Inner),Output:["_col2","_col4","_col10"] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_100] + PartitionCols:_col5 + Merge Join Operator [MERGEJOIN_269] (rows=4049224 width=4) + Conds:RS_46._col0=RS_311._col1(Inner),Output:["_col5"] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_46] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_265] (rows=39720279 width=4) + Conds:RS_293._col1, _col2=RS_296._col0, _col1(Inner),Output:["_col0"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_293] + PartitionCols:_col1, _col2 + Select Operator [SEL_292] (rows=40000000 width=188) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_291] (rows=40000000 width=188) + predicate:(ca_address_sk is not null and ca_county is not null and ca_state is not null) + TableScan [TS_6] (rows=40000000 width=188) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_county","ca_state"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_296] + PartitionCols:_col0, _col1 + Select Operator [SEL_295] (rows=1704 width=184) + Output:["_col0","_col1"] + Filter Operator [FIL_294] (rows=1704 width=184) + predicate:(s_county is not null and s_state is not null) + TableScan [TS_9] (rows=1704 width=184) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_county","s_state"] + <-Reducer 21 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_311] + PartitionCols:_col1 + Select Operator [SEL_310] (rows=4049224 width=8) + Output:["_col0","_col1"] + Group By Operator [GBY_309] (rows=4049224 width=8) + Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col0, _col1 + Group By Operator [GBY_39] (rows=4049224 width=8) + Output:["_col0","_col1"],keys:_col6, _col5 + Merge Join Operator [MERGEJOIN_268] (rows=4049224 width=8) + Conds:RS_35._col1=RS_308._col0(Inner),Output:["_col5","_col6"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_308] PartitionCols:_col0 - Select Operator [SEL_302] (rows=453 width=4) - Output:["_col0"] - Filter Operator [FIL_301] (rows=453 width=186) - predicate:((i_class = 'consignment') and (i_category = 'Jewelry') and i_item_sk is not null) - TableScan [TS_23] (rows=462000 width=186) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_264] (rows=429048824 width=7) - Conds:Union 17._col0=RS_297._col0(Inner),Output:["_col1","_col2"] - <-Map 23 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_297] + Select Operator [SEL_307] (rows=80000000 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_306] (rows=80000000 width=8) + predicate:(c_customer_sk is not null and c_current_addr_sk is not null) + TableScan [TS_26] (rows=80000000 width=8) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_267] (rows=4049224 width=1) + Conds:RS_32._col2=RS_305._col0(Inner),Output:["_col1"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_305] PartitionCols:_col0 - Select Operator [SEL_296] (rows=50 width=4) + Select Operator [SEL_304] (rows=453 width=4) Output:["_col0"] - Filter Operator [FIL_295] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) - TableScan [TS_20] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Union 17 [SIMPLE_EDGE] - <-Map 16 [CONTAINS] vectorized - Reduce Output Operator [RS_360] - PartitionCols:_col0 - Select Operator [SEL_359] (rows=285117831 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_358] (rows=285117831 width=11) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_273] (rows=287989836 width=11) - Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_356] - Group By Operator [GBY_355] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 23 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_300] - Group By Operator [GBY_299] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_298] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_296] - <-Map 22 [CONTAINS] vectorized - Reduce Output Operator [RS_363] - PartitionCols:_col0 - Select Operator [SEL_362] (rows=143930993 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_361] (rows=143930993 width=11) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_278] (rows=144002668 width=11) - Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_357] - Please refer to the previous Group By Operator [GBY_355] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_99] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_262] (rows=525327388 width=114) - Conds:RS_285._col0=RS_288._col0(Inner),Output:["_col1","_col2","_col4"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_285] - PartitionCols:_col0 - Select Operator [SEL_284] (rows=525327388 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_283] (rows=525327388 width=114) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_288] - PartitionCols:_col0 - Select Operator [SEL_287] (rows=73049 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_286] (rows=73049 width=8) - predicate:(d_date_sk is not null and d_month_seq is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + Filter Operator [FIL_303] (rows=453 width=186) + predicate:((i_class = 'consignment') and (i_category = 'Jewelry') and i_item_sk is not null) + TableScan [TS_23] (rows=462000 width=186) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_266] (rows=429048824 width=7) + Conds:Union 17._col0=RS_299._col0(Inner),Output:["_col1","_col2"] + <-Map 23 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_299] + PartitionCols:_col0 + Select Operator [SEL_298] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_297] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 3) and d_date_sk is not null) + TableScan [TS_20] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Union 17 [SIMPLE_EDGE] + <-Map 16 [CONTAINS] vectorized + Reduce Output Operator [RS_364] + PartitionCols:_col0 + Select Operator [SEL_363] (rows=285117831 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_362] (rows=285117831 width=11) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_275] (rows=287989836 width=11) + Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_360] + Group By Operator [GBY_359] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 23 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_302] + Group By Operator [GBY_301] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_300] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_298] + <-Map 22 [CONTAINS] vectorized + Reduce Output Operator [RS_367] + PartitionCols:_col0 + Select Operator [SEL_366] (rows=143930993 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_365] (rows=143930993 width=11) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_280] (rows=144002668 width=11) + Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_361] + Please refer to the previous Group By Operator [GBY_359] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_99] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_264] (rows=525327388 width=114) + Conds:RS_287._col0=RS_290._col0(Inner),Output:["_col1","_col2","_col4"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_287] + PartitionCols:_col0 + Select Operator [SEL_286] (rows=525327388 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_285] (rows=525327388 width=114) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_ext_sales_price"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_290] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=73049 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_288] (rows=73049 width=8) + predicate:(d_date_sk is not null and d_month_seq is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] diff --git ql/src/test/results/clientpositive/perf/tez/query55.q.out ql/src/test/results/clientpositive/perf/tez/query55.q.out index 5cee50ed50..36def221f6 100644 --- ql/src/test/results/clientpositive/perf/tez/query55.q.out +++ ql/src/test/results/clientpositive/perf/tez/query55.q.out @@ -47,65 +47,67 @@ Stage-0 limit:-1 Stage-1 Reducer 5 vectorized - File Output Operator [FS_74] - Limit [LIM_73] (rows=100 width=220) + File Output Operator [FS_76] + Limit [LIM_75] (rows=100 width=220) Number of rows:100 - Select Operator [SEL_72] (rows=7333 width=220) + Select Operator [SEL_74] (rows=7333 width=220) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - Select Operator [SEL_70] (rows=7333 width=220) + SHUFFLE [RS_73] + Select Operator [SEL_72] (rows=7333 width=220) Output:["_col1","_col2","_col3"] - Group By Operator [GBY_69] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1 - Group By Operator [GBY_16] (rows=7333 width=216) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 - Merge Join Operator [MERGEJOIN_54] (rows=84037218 width=183) - Conds:RS_12._col1=RS_68._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_68] - PartitionCols:_col0 - Select Operator [SEL_67] (rows=7333 width=107) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_66] (rows=7333 width=111) - predicate:((i_manager_id = 36) and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=111) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_53] (rows=550076554 width=110) - Conds:RS_65._col0=RS_57._col0(Inner),Output:["_col1","_col2"] - <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_57] - PartitionCols:_col0 - Select Operator [SEL_56] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_55] (rows=50 width=12) - predicate:((d_year = 2001) and (d_moy = 12) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_65] - PartitionCols:_col0 - Select Operator [SEL_64] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_63] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_62] - Group By Operator [GBY_61] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_60] - Group By Operator [GBY_59] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_58] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_56] + Top N Key Operator [TNK_71] (rows=7333 width=216) + keys:_col2, _col0,top n:100 + Group By Operator [GBY_70] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1 + Group By Operator [GBY_16] (rows=7333 width=216) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)"],keys:_col5, _col6 + Merge Join Operator [MERGEJOIN_55] (rows=84037218 width=183) + Conds:RS_12._col1=RS_69._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_69] + PartitionCols:_col0 + Select Operator [SEL_68] (rows=7333 width=107) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_67] (rows=7333 width=111) + predicate:((i_manager_id = 36) and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=111) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_brand","i_manager_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_54] (rows=550076554 width=110) + Conds:RS_66._col0=RS_58._col0(Inner),Output:["_col1","_col2"] + <-Map 6 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_58] + PartitionCols:_col0 + Select Operator [SEL_57] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_56] (rows=50 width=12) + predicate:((d_year = 2001) and (d_moy = 12) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_66] + PartitionCols:_col0 + Select Operator [SEL_65] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_64] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_63] + Group By Operator [GBY_62] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_61] + Group By Operator [GBY_60] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_59] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_57] diff --git ql/src/test/results/clientpositive/perf/tez/query56.q.out ql/src/test/results/clientpositive/perf/tez/query56.q.out index 2be886a3eb..8adb39ad20 100644 --- ql/src/test/results/clientpositive/perf/tez/query56.q.out +++ ql/src/test/results/clientpositive/perf/tez/query56.q.out @@ -177,224 +177,226 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_357] - Limit [LIM_356] (rows=100 width=212) + File Output Operator [FS_359] + Limit [LIM_358] (rows=100 width=212) Number of rows:100 - Select Operator [SEL_355] (rows=355 width=212) + Select Operator [SEL_357] (rows=355 width=212) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_354] - Group By Operator [GBY_353] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 11 [CONTAINS] vectorized - Reduce Output Operator [RS_373] - PartitionCols:_col0 - Group By Operator [GBY_372] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_371] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_109] - PartitionCols:_col0 - Group By Operator [GBY_108] (rows=9585 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_304] (rows=31485548 width=211) - Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_104] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_293] (rows=15609 width=104) - Conds:RS_319._col1=RS_325._col0(Inner),Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col1 - Select Operator [SEL_318] (rows=462000 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_317] (rows=462000 width=104) - predicate:(i_item_id is not null and i_item_sk is not null) - TableScan [TS_0] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_325] - PartitionCols:_col0 - Group By Operator [GBY_324] (rows=10500 width=100) - Output:["_col0"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Group By Operator [GBY_322] (rows=10500 width=100) - Output:["_col0"],keys:i_item_id - Select Operator [SEL_321] (rows=21000 width=189) - Output:["i_item_id"] - Filter Operator [FIL_320] (rows=21000 width=189) - predicate:((i_color) IN ('orchid', 'chiffon', 'lace') and i_item_id is not null) - TableScan [TS_3] (rows=462000 width=189) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_color"] - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_105] - PartitionCols:_col2 - Select Operator [SEL_100] (rows=143931246 width=115) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=115) - Conds:RS_97._col2=RS_349._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_349] - PartitionCols:_col0 - Select Operator [SEL_346] (rows=8000000 width=4) - Output:["_col0"] - Filter Operator [FIL_345] (rows=8000000 width=112) - predicate:((ca_gmt_offset = -8) and ca_address_sk is not null) - TableScan [TS_16] (rows=40000000 width=112) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_300] (rows=143931246 width=119) - Conds:RS_370._col0=RS_332._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_332] - PartitionCols:_col0 - Select Operator [SEL_327] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_326] (rows=50 width=12) - predicate:((d_year = 2000) and (d_moy = 1) and d_date_sk is not null) - TableScan [TS_13] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_370] - PartitionCols:_col0 - Select Operator [SEL_369] (rows=143931246 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_368] (rows=143931246 width=123) - predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_85] (rows=144002668 width=123) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_367] - Group By Operator [GBY_366] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_339] - Group By Operator [GBY_336] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_333] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 4 [CONTAINS] vectorized - Reduce Output Operator [RS_352] - PartitionCols:_col0 - Group By Operator [GBY_351] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_350] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col0 - Group By Operator [GBY_33] (rows=30175 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_302] (rows=114917468 width=188) - Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_293] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col2 - Select Operator [SEL_25] (rows=525327191 width=110) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=110) - Conds:RS_22._col2=RS_347._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_347] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_294] (rows=525327191 width=114) - Conds:RS_344._col0=RS_328._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_328] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] - PartitionCols:_col0 - Select Operator [SEL_343] (rows=525327191 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_342] (rows=525327191 width=118) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_10] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_341] - Group By Operator [GBY_340] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_337] - Group By Operator [GBY_334] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_329] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] - <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_365] - PartitionCols:_col0 - Group By Operator [GBY_364] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Group By Operator [GBY_363] (rows=355 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_71] - PartitionCols:_col0 - Group By Operator [GBY_70] (rows=18460 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_303] (rows=62370668 width=209) - Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_293] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_67] - PartitionCols:_col3 - Select Operator [SEL_62] (rows=285117733 width=115) - Output:["_col3","_col4"] - Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=115) - Conds:RS_59._col1=RS_348._col0(Inner),Output:["_col2","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_346] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_59] + SHUFFLE [RS_356] + Top N Key Operator [TNK_355] (rows=355 width=212) + keys:_col1,top n:100 + Group By Operator [GBY_354] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 11 [CONTAINS] vectorized + Reduce Output Operator [RS_375] + PartitionCols:_col0 + Group By Operator [GBY_374] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_373] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_109] + PartitionCols:_col0 + Group By Operator [GBY_108] (rows=9585 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_305] (rows=31485548 width=211) + Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_104] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_294] (rows=15609 width=104) + Conds:RS_320._col1=RS_326._col0(Inner),Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_320] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_297] (rows=285117733 width=119) - Conds:RS_362._col0=RS_330._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_330] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_327] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_362] + Select Operator [SEL_319] (rows=462000 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_318] (rows=462000 width=104) + predicate:(i_item_id is not null and i_item_sk is not null) + TableScan [TS_0] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_326] + PartitionCols:_col0 + Group By Operator [GBY_325] (rows=10500 width=100) + Output:["_col0"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_324] PartitionCols:_col0 - Select Operator [SEL_361] (rows=285117733 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_360] (rows=285117733 width=123) - predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_47] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_359] - Group By Operator [GBY_358] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_338] - Group By Operator [GBY_335] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_331] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_327] + Group By Operator [GBY_323] (rows=10500 width=100) + Output:["_col0"],keys:i_item_id + Select Operator [SEL_322] (rows=21000 width=189) + Output:["i_item_id"] + Filter Operator [FIL_321] (rows=21000 width=189) + predicate:((i_color) IN ('orchid', 'chiffon', 'lace') and i_item_id is not null) + TableScan [TS_3] (rows=462000 width=189) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_color"] + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_105] + PartitionCols:_col2 + Select Operator [SEL_100] (rows=143931246 width=115) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_302] (rows=143931246 width=115) + Conds:RS_97._col2=RS_350._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_350] + PartitionCols:_col0 + Select Operator [SEL_347] (rows=8000000 width=4) + Output:["_col0"] + Filter Operator [FIL_346] (rows=8000000 width=112) + predicate:((ca_gmt_offset = -8) and ca_address_sk is not null) + TableScan [TS_16] (rows=40000000 width=112) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_97] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=119) + Conds:RS_372._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_333] + PartitionCols:_col0 + Select Operator [SEL_328] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_327] (rows=50 width=12) + predicate:((d_year = 2000) and (d_moy = 1) and d_date_sk is not null) + TableScan [TS_13] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_372] + PartitionCols:_col0 + Select Operator [SEL_371] (rows=143931246 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_370] (rows=143931246 width=123) + predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_85] (rows=144002668 width=123) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_369] + Group By Operator [GBY_368] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_340] + Group By Operator [GBY_337] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_334] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] + <-Reducer 4 [CONTAINS] vectorized + Reduce Output Operator [RS_353] + PartitionCols:_col0 + Group By Operator [GBY_352] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_351] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col0 + Group By Operator [GBY_33] (rows=30175 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_303] (rows=114917468 width=188) + Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_294] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col2 + Select Operator [SEL_25] (rows=525327191 width=110) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_296] (rows=525327191 width=110) + Conds:RS_22._col2=RS_348._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_348] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_347] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=114) + Conds:RS_345._col0=RS_329._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_329] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_328] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_345] + PartitionCols:_col0 + Select Operator [SEL_344] (rows=525327191 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_343] (rows=525327191 width=118) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_10] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_342] + Group By Operator [GBY_341] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_338] + Group By Operator [GBY_335] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_330] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] + <-Reducer 9 [CONTAINS] vectorized + Reduce Output Operator [RS_367] + PartitionCols:_col0 + Group By Operator [GBY_366] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Group By Operator [GBY_365] (rows=355 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_71] + PartitionCols:_col0 + Group By Operator [GBY_70] (rows=18460 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_304] (rows=62370668 width=209) + Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_294] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_67] + PartitionCols:_col3 + Select Operator [SEL_62] (rows=285117733 width=115) + Output:["_col3","_col4"] + Merge Join Operator [MERGEJOIN_299] (rows=285117733 width=115) + Conds:RS_59._col1=RS_349._col0(Inner),Output:["_col2","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_347] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_59] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=119) + Conds:RS_364._col0=RS_331._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_331] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_328] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_364] + PartitionCols:_col0 + Select Operator [SEL_363] (rows=285117733 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_362] (rows=285117733 width=123) + predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_47] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 21 [BROADCAST_EDGE] vectorized + BROADCAST [RS_361] + Group By Operator [GBY_360] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_339] + Group By Operator [GBY_336] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_332] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_328] diff --git ql/src/test/results/clientpositive/perf/tez/query57.q.out ql/src/test/results/clientpositive/perf/tez/query57.q.out index b732cc873f..fecf887b91 100644 --- ql/src/test/results/clientpositive/perf/tez/query57.q.out +++ ql/src/test/results/clientpositive/perf/tez/query57.q.out @@ -123,138 +123,140 @@ Stage-0 limit:-1 Stage-1 Reducer 8 vectorized - File Output Operator [FS_321] - Limit [LIM_320] (rows=100 width=758) + File Output Operator [FS_322] + Limit [LIM_321] (rows=100 width=758) Number of rows:100 - Select Operator [SEL_319] (rows=397735 width=758) + Select Operator [SEL_320] (rows=397735 width=758) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_110] Select Operator [SEL_109] (rows=397735 width=758) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_278] (rows=397735 width=646) - Conds:RS_106._col5, _col6, _col12, _col7=RS_306._col0, _col1, _col4, _col2(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col10","_col11","_col16"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_306] - PartitionCols:_col0, _col1, _col4, _col2 - Select Operator [SEL_304] (rows=2386410 width=404) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_302] (rows=2386410 width=408) - predicate:rank_window_0 is not null - PTF Operator [PTF_300] (rows=2386410 width=408) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4"}] - Select Operator [SEL_299] (rows=2386410 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_297] - PartitionCols:_col1, _col0, _col4 - Group By Operator [GBY_296] (rows=2386410 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_93] - PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_92] (rows=285117980 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)"],keys:_col10, _col11, _col5, _col6, _col8 - Merge Join Operator [MERGEJOIN_276] (rows=285117980 width=407) - Conds:RS_88._col2=RS_295._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10","_col11"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_295] - PartitionCols:_col0 - Select Operator [SEL_294] (rows=462000 width=194) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_293] (rows=462000 width=194) - predicate:(i_item_sk is not null and i_category is not null and i_brand is not null) - TableScan [TS_79] (rows=462000 width=194) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_275] (rows=285117980 width=221) - Conds:RS_85._col1=RS_292._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_292] - PartitionCols:_col0 - Select Operator [SEL_291] (rows=60 width=102) - Output:["_col0","_col1"] - Filter Operator [FIL_290] (rows=60 width=102) - predicate:(cc_call_center_sk is not null and cc_name is not null) - TableScan [TS_76] (rows=60 width=102) - default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_274] (rows=285117980 width=127) - Conds:RS_289._col0=RS_281._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] - PartitionCols:_col0 - Select Operator [SEL_280] (rows=564 width=12) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_279] (rows=564 width=12) - predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1))) and d_date_sk is not null) - TableScan [TS_73] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_289] - PartitionCols:_col0 - Select Operator [SEL_288] (rows=285117980 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_287] (rows=285117980 width=123) - predicate:(cs_sold_date_sk is not null and cs_call_center_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_70] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_item_sk","cs_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_286] - Group By Operator [GBY_285] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] - Group By Operator [GBY_283] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_282] (rows=564 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_280] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_106] - PartitionCols:_col5, _col6, _col12, _col7 - Merge Join Operator [MERGEJOIN_277] (rows=397735 width=636) - Conds:RS_307._col0, _col1, _col4, _col2=RS_318._col0, _col1, _col7, _col2(Inner),Output:["_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_307] - PartitionCols:_col0, _col1, _col4, _col2 - Select Operator [SEL_305] (rows=2386410 width=404) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_303] (rows=2386410 width=408) - predicate:rank_window_0 is not null - PTF Operator [PTF_301] (rows=2386410 width=408) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4"}] - Please refer to the previous Select Operator [SEL_299] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] - PartitionCols:_col0, _col1, _col7, _col2 - Select Operator [SEL_317] (rows=397735 width=524) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_316] (rows=397735 width=524) - predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col6 - _col0)) / _col0) > 0.1)) ELSE (false) END - Select Operator [SEL_315] (rows=795470 width=520) - Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_314] (rows=795470 width=520) - predicate:((_col0 > 0) and rank_window_1 is not null and (_col3 = 2000)) - PTF Operator [PTF_313] (rows=2386410 width=520) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col3 ASC NULLS LAST, _col4 ASC NULLS LAST","partition by:":"_col2, _col1, _col5"}] - Select Operator [SEL_312] (rows=2386410 width=520) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_311] - PartitionCols:_col1, _col0, _col4 - Select Operator [SEL_310] (rows=2386410 width=408) - Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_309] (rows=2386410 width=408) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col2 ASC NULLS FIRST","partition by:":"_col1, _col0, _col4, _col2"}] - Select Operator [SEL_308] (rows=2386410 width=408) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_298] - PartitionCols:_col1, _col0, _col4, _col2 - Please refer to the previous Group By Operator [GBY_296] + Top N Key Operator [TNK_178] (rows=397735 width=646) + keys:(_col10 - _col11), _col8,top n:100 + Merge Join Operator [MERGEJOIN_279] (rows=397735 width=646) + Conds:RS_106._col5, _col6, _col12, _col7=RS_307._col0, _col1, _col4, _col2(Inner),Output:["_col3","_col5","_col6","_col8","_col9","_col10","_col11","_col16"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_307] + PartitionCols:_col0, _col1, _col4, _col2 + Select Operator [SEL_305] (rows=2386410 width=404) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_303] (rows=2386410 width=408) + predicate:rank_window_0 is not null + PTF Operator [PTF_301] (rows=2386410 width=408) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4"}] + Select Operator [SEL_300] (rows=2386410 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_298] + PartitionCols:_col1, _col0, _col4 + Group By Operator [GBY_297] (rows=2386410 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_93] + PartitionCols:_col0, _col1, _col2, _col3, _col4 + Group By Operator [GBY_92] (rows=285117980 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col3)"],keys:_col10, _col11, _col5, _col6, _col8 + Merge Join Operator [MERGEJOIN_277] (rows=285117980 width=407) + Conds:RS_88._col2=RS_296._col0(Inner),Output:["_col3","_col5","_col6","_col8","_col10","_col11"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_296] + PartitionCols:_col0 + Select Operator [SEL_295] (rows=462000 width=194) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_294] (rows=462000 width=194) + predicate:(i_item_sk is not null and i_category is not null and i_brand is not null) + TableScan [TS_79] (rows=462000 width=194) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_category"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_276] (rows=285117980 width=221) + Conds:RS_85._col1=RS_293._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col8"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_293] + PartitionCols:_col0 + Select Operator [SEL_292] (rows=60 width=102) + Output:["_col0","_col1"] + Filter Operator [FIL_291] (rows=60 width=102) + predicate:(cc_call_center_sk is not null and cc_name is not null) + TableScan [TS_76] (rows=60 width=102) + default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_275] (rows=285117980 width=127) + Conds:RS_290._col0=RS_282._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_282] + PartitionCols:_col0 + Select Operator [SEL_281] (rows=564 width=12) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_280] (rows=564 width=12) + predicate:((d_year) IN (2000, 1999, 2001) and ((d_year = 2000) or (struct(d_year,d_moy)) IN (const struct(1999,12), const struct(2001,1))) and d_date_sk is not null) + TableScan [TS_73] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_290] + PartitionCols:_col0 + Select Operator [SEL_289] (rows=285117980 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_288] (rows=285117980 width=123) + predicate:(cs_sold_date_sk is not null and cs_call_center_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_83_date_dim_d_date_sk_min) AND DynamicValue(RS_83_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_83_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_70] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_item_sk","cs_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_287] + Group By Operator [GBY_286] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_285] + Group By Operator [GBY_284] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_283] (rows=564 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_281] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_106] + PartitionCols:_col5, _col6, _col12, _col7 + Merge Join Operator [MERGEJOIN_278] (rows=397735 width=636) + Conds:RS_308._col0, _col1, _col4, _col2=RS_319._col0, _col1, _col7, _col2(Inner),Output:["_col3","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] + <-Reducer 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_308] + PartitionCols:_col0, _col1, _col4, _col2 + Select Operator [SEL_306] (rows=2386410 width=404) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_304] (rows=2386410 width=408) + predicate:rank_window_0 is not null + PTF Operator [PTF_302] (rows=2386410 width=408) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS LAST, _col3 ASC NULLS LAST","partition by:":"_col1, _col0, _col4"}] + Please refer to the previous Select Operator [SEL_300] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_319] + PartitionCols:_col0, _col1, _col7, _col2 + Select Operator [SEL_318] (rows=397735 width=524) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_317] (rows=397735 width=524) + predicate:CASE WHEN ((_col0 > 0)) THEN (((abs((_col6 - _col0)) / _col0) > 0.1)) ELSE (false) END + Select Operator [SEL_316] (rows=795470 width=520) + Output:["rank_window_1","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_315] (rows=795470 width=520) + predicate:((_col0 > 0) and rank_window_1 is not null and (_col3 = 2000)) + PTF Operator [PTF_314] (rows=2386410 width=520) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col3 ASC NULLS LAST, _col4 ASC NULLS LAST","partition by:":"_col2, _col1, _col5"}] + Select Operator [SEL_313] (rows=2386410 width=520) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_312] + PartitionCols:_col1, _col0, _col4 + Select Operator [SEL_311] (rows=2386410 width=408) + Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5"] + PTF Operator [PTF_310] (rows=2386410 width=408) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col2 ASC NULLS FIRST","partition by:":"_col1, _col0, _col4, _col2"}] + Select Operator [SEL_309] (rows=2386410 width=408) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_299] + PartitionCols:_col1, _col0, _col4, _col2 + Please refer to the previous Group By Operator [GBY_297] diff --git ql/src/test/results/clientpositive/perf/tez/query58.q.out ql/src/test/results/clientpositive/perf/tez/query58.q.out index 57f3477e48..653f029abb 100644 --- ql/src/test/results/clientpositive/perf/tez/query58.q.out +++ ql/src/test/results/clientpositive/perf/tez/query58.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[404][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 22' is a cross product +Warning: Shuffle Join MERGEJOIN[405][tables = [$hdt$_4, $hdt$_5]] in Stage 'Reducer 22' is a cross product PREHOOK: query: explain with ss_items as (select i_item_id item_id @@ -171,229 +171,231 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_470] - Limit [LIM_469] (rows=1 width=884) + File Output Operator [FS_471] + Limit [LIM_470] (rows=1 width=884) Number of rows:100 - Select Operator [SEL_468] (rows=1 width=884) + Select Operator [SEL_469] (rows=1 width=884) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_163] Select Operator [SEL_162] (rows=1 width=884) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_158] (rows=1 width=1108) - predicate:(_col9 BETWEEN _col2 AND _col3 and _col9 BETWEEN _col6 AND _col7 and _col1 BETWEEN _col10 AND _col11 and _col5 BETWEEN _col10 AND _col11) - Merge Join Operator [MERGEJOIN_419] (rows=3836 width=1108) - Conds:RS_155._col0=RS_467._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col9","_col10","_col11"] - <-Reducer 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_467] - PartitionCols:_col0 - Select Operator [SEL_466] (rows=310774 width=436) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_465] (rows=310774 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_147] - PartitionCols:_col0 - Group By Operator [GBY_146] (rows=37292880 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 - Merge Join Operator [MERGEJOIN_417] (rows=143966864 width=211) - Conds:RS_142._col0=RS_143._col0(Inner),Output:["_col2","_col4"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_143] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_406] (rows=2 width=4) - Conds:RS_422._col1=RS_438._col0(Inner),Output:["_col0"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_422] - PartitionCols:_col1 - Select Operator [SEL_421] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_420] (rows=73049 width=98) - predicate:(d_date is not null and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Reducer 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_438] - PartitionCols:_col0 - Group By Operator [GBY_437] (rows=2 width=94) - Output:["_col0"],keys:KEY._col0 - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col0 - Group By Operator [GBY_31] (rows=2 width=94) - Output:["_col0"],keys:_col2 - Merge Join Operator [MERGEJOIN_405] (rows=5 width=94) - Conds:RS_27._col1=RS_435._col1(Inner),Output:["_col2"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_435] - PartitionCols:_col1 - Select Operator [SEL_433] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_431] (rows=73049 width=98) - predicate:(d_week_seq is not null and d_date is not null) - TableScan [TS_21] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_404] (rows=1 width=4) - Conds:(Inner),Output:["_col1"] - <-Map 25 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_436] - Select Operator [SEL_434] (rows=1 width=4) - Output:["_col0"] - Filter Operator [FIL_432] (rows=1 width=98) - predicate:((d_date = '1998-02-19') and d_week_seq is not null) - Please refer to the previous TableScan [TS_21] - <-Reducer 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_430] - Select Operator [SEL_429] (rows=1 width=8) - Filter Operator [FIL_428] (rows=1 width=8) - predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_427] (rows=1 width=8) - Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Map 20 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_426] - Group By Operator [GBY_425] (rows=1 width=8) - Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_424] (rows=1 width=94) - Filter Operator [FIL_423] (rows=1 width=94) - predicate:(d_date = '1998-02-19') - TableScan [TS_9] (rows=73049 width=94) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_142] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_411] (rows=143966864 width=215) - Conds:RS_464._col1=RS_448._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_448] - PartitionCols:_col0 - Select Operator [SEL_445] (rows=462000 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_444] (rows=462000 width=104) - predicate:(i_item_sk is not null and i_item_id is not null) - TableScan [TS_3] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_464] - PartitionCols:_col1 - Select Operator [SEL_463] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_462] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_143_date_dim_d_date_sk_min) AND DynamicValue(RS_143_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_143_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_100] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] - <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_461] - Group By Operator [GBY_460] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 16 [CUSTOM_SIMPLE_EDGE] - SHUFFLE [RS_363] - Group By Operator [GBY_362] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_361] (rows=2 width=4) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_406] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_155] - PartitionCols:_col0 - Filter Operator [FIL_153] (rows=3836 width=772) - predicate:(_col1 BETWEEN _col6 AND _col7 and _col5 BETWEEN _col2 AND _col3) - Merge Join Operator [MERGEJOIN_418] (rows=310774 width=772) - Conds:RS_451._col0=RS_459._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7"] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_459] - PartitionCols:_col0 - Select Operator [SEL_458] (rows=310774 width=436) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_457] (rows=310774 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col0 - Group By Operator [GBY_96] (rows=138294430 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 - Merge Join Operator [MERGEJOIN_416] (rows=550076554 width=206) - Conds:RS_92._col0=RS_93._col0(Inner),Output:["_col2","_col4"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_93] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_406] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_92] + Top N Key Operator [TNK_260] (rows=1 width=1108) + keys:_col0, _col5,top n:100 + Filter Operator [FIL_158] (rows=1 width=1108) + predicate:(_col9 BETWEEN _col2 AND _col3 and _col9 BETWEEN _col6 AND _col7 and _col1 BETWEEN _col10 AND _col11 and _col5 BETWEEN _col10 AND _col11) + Merge Join Operator [MERGEJOIN_420] (rows=3836 width=1108) + Conds:RS_155._col0=RS_468._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col9","_col10","_col11"] + <-Reducer 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_468] + PartitionCols:_col0 + Select Operator [SEL_467] (rows=310774 width=436) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_466] (rows=310774 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_147] + PartitionCols:_col0 + Group By Operator [GBY_146] (rows=37292880 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 + Merge Join Operator [MERGEJOIN_418] (rows=143966864 width=211) + Conds:RS_142._col0=RS_143._col0(Inner),Output:["_col2","_col4"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_143] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_407] (rows=2 width=4) + Conds:RS_423._col1=RS_439._col0(Inner),Output:["_col0"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_423] + PartitionCols:_col1 + Select Operator [SEL_422] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_421] (rows=73049 width=98) + predicate:(d_date is not null and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Reducer 24 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_439] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_407] (rows=550076554 width=210) - Conds:RS_456._col1=RS_447._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_447] + Group By Operator [GBY_438] (rows=2 width=94) + Output:["_col0"],keys:KEY._col0 + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_32] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_445] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_456] - PartitionCols:_col1 - Select Operator [SEL_455] (rows=550076554 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_454] (rows=550076554 width=114) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_93_date_dim_d_date_sk_min) AND DynamicValue(RS_93_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_93_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_50] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_453] - Group By Operator [GBY_452] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 16 [CUSTOM_SIMPLE_EDGE] - SHUFFLE [RS_317] - Group By Operator [GBY_316] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_315] (rows=2 width=4) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_406] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_451] - PartitionCols:_col0 - Select Operator [SEL_450] (rows=310774 width=436) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_449] (rows=310774 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_47] - PartitionCols:_col0 - Group By Operator [GBY_46] (rows=73653438 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 - Merge Join Operator [MERGEJOIN_415] (rows=286549727 width=211) - Conds:RS_42._col0=RS_43._col0(Inner),Output:["_col2","_col4"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_43] + Group By Operator [GBY_31] (rows=2 width=94) + Output:["_col0"],keys:_col2 + Merge Join Operator [MERGEJOIN_406] (rows=5 width=94) + Conds:RS_27._col1=RS_436._col1(Inner),Output:["_col2"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_436] + PartitionCols:_col1 + Select Operator [SEL_434] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_432] (rows=73049 width=98) + predicate:(d_week_seq is not null and d_date is not null) + TableScan [TS_21] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_405] (rows=1 width=4) + Conds:(Inner),Output:["_col1"] + <-Map 25 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_437] + Select Operator [SEL_435] (rows=1 width=4) + Output:["_col0"] + Filter Operator [FIL_433] (rows=1 width=98) + predicate:((d_date = '1998-02-19') and d_week_seq is not null) + Please refer to the previous TableScan [TS_21] + <-Reducer 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_431] + Select Operator [SEL_430] (rows=1 width=8) + Filter Operator [FIL_429] (rows=1 width=8) + predicate:(sq_count_check(_col0) <= 1) + Group By Operator [GBY_428] (rows=1 width=8) + Output:["_col0"],aggregations:["count(VALUE._col0)"] + <-Map 20 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_427] + Group By Operator [GBY_426] (rows=1 width=8) + Output:["_col0"],aggregations:["count()"] + Select Operator [SEL_425] (rows=1 width=94) + Filter Operator [FIL_424] (rows=1 width=94) + predicate:(d_date = '1998-02-19') + TableScan [TS_9] (rows=73049 width=94) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_142] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_412] (rows=143966864 width=215) + Conds:RS_465._col1=RS_449._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_449] PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_406] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_42] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_403] (rows=286549727 width=215) - Conds:RS_443._col1=RS_446._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_446] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_445] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_443] - PartitionCols:_col1 - Select Operator [SEL_442] (rows=286549727 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_441] (rows=286549727 width=119) - predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_43_date_dim_d_date_sk_min) AND DynamicValue(RS_43_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_43_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=287989836 width=119) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_440] - Group By Operator [GBY_439] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Reducer 16 [CUSTOM_SIMPLE_EDGE] - SHUFFLE [RS_267] - Group By Operator [GBY_266] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_265] (rows=2 width=4) - Output:["_col0"] - Please refer to the previous Merge Join Operator [MERGEJOIN_406] + Select Operator [SEL_446] (rows=462000 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_445] (rows=462000 width=104) + predicate:(i_item_sk is not null and i_item_id is not null) + TableScan [TS_3] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_465] + PartitionCols:_col1 + Select Operator [SEL_464] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_463] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_143_date_dim_d_date_sk_min) AND DynamicValue(RS_143_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_143_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_100] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_ext_sales_price"] + <-Reducer 19 [BROADCAST_EDGE] vectorized + BROADCAST [RS_462] + Group By Operator [GBY_461] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 16 [CUSTOM_SIMPLE_EDGE] + SHUFFLE [RS_364] + Group By Operator [GBY_363] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_362] (rows=2 width=4) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_407] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_155] + PartitionCols:_col0 + Filter Operator [FIL_153] (rows=3836 width=772) + predicate:(_col1 BETWEEN _col6 AND _col7 and _col5 BETWEEN _col2 AND _col3) + Merge Join Operator [MERGEJOIN_419] (rows=310774 width=772) + Conds:RS_452._col0=RS_460._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7"] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_460] + PartitionCols:_col0 + Select Operator [SEL_459] (rows=310774 width=436) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_458] (rows=310774 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_97] + PartitionCols:_col0 + Group By Operator [GBY_96] (rows=138294430 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 + Merge Join Operator [MERGEJOIN_417] (rows=550076554 width=206) + Conds:RS_92._col0=RS_93._col0(Inner),Output:["_col2","_col4"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_93] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_407] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_92] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_408] (rows=550076554 width=210) + Conds:RS_457._col1=RS_448._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_448] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_446] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_457] + PartitionCols:_col1 + Select Operator [SEL_456] (rows=550076554 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_455] (rows=550076554 width=114) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_93_date_dim_d_date_sk_min) AND DynamicValue(RS_93_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_93_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_50] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_454] + Group By Operator [GBY_453] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 16 [CUSTOM_SIMPLE_EDGE] + SHUFFLE [RS_318] + Group By Operator [GBY_317] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_316] (rows=2 width=4) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_407] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_452] + PartitionCols:_col0 + Select Operator [SEL_451] (rows=310774 width=436) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_450] (rows=310774 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_47] + PartitionCols:_col0 + Group By Operator [GBY_46] (rows=73653438 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 + Merge Join Operator [MERGEJOIN_416] (rows=286549727 width=211) + Conds:RS_42._col0=RS_43._col0(Inner),Output:["_col2","_col4"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_407] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_42] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_404] (rows=286549727 width=215) + Conds:RS_444._col1=RS_447._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_447] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_446] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_444] + PartitionCols:_col1 + Select Operator [SEL_443] (rows=286549727 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_442] (rows=286549727 width=119) + predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_43_date_dim_d_date_sk_min) AND DynamicValue(RS_43_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_43_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=287989836 width=119) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 17 [BROADCAST_EDGE] vectorized + BROADCAST [RS_441] + Group By Operator [GBY_440] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Reducer 16 [CUSTOM_SIMPLE_EDGE] + SHUFFLE [RS_268] + Group By Operator [GBY_267] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_266] (rows=2 width=4) + Output:["_col0"] + Please refer to the previous Merge Join Operator [MERGEJOIN_407] diff --git ql/src/test/results/clientpositive/perf/tez/query59.q.out ql/src/test/results/clientpositive/perf/tez/query59.q.out index 566f888d40..05de76dc0f 100644 --- ql/src/test/results/clientpositive/perf/tez/query59.q.out +++ ql/src/test/results/clientpositive/perf/tez/query59.q.out @@ -111,128 +111,130 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_211] - Limit [LIM_210] (rows=100 width=976) + File Output Operator [FS_212] + Limit [LIM_211] (rows=100 width=976) Number of rows:100 - Select Operator [SEL_209] (rows=862591 width=976) + Select Operator [SEL_210] (rows=862591 width=976) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_59] Select Operator [SEL_58] (rows=862591 width=976) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Merge Join Operator [MERGEJOIN_183] (rows=862591 width=1648) - Conds:RS_55._col11, _col0=RS_56._col1, (_col0 - 52)(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12","_col15","_col16","_col17","_col18","_col19","_col20"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_56] - PartitionCols:_col1, (_col0 - 52) - Select Operator [SEL_48] (rows=26628 width=776) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_182] (rows=26628 width=776) - Conds:RS_45._col1=RS_208._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col10"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_208] + Top N Key Operator [TNK_97] (rows=862591 width=1648) + keys:_col12, _col11, _col0,top n:100 + Merge Join Operator [MERGEJOIN_184] (rows=862591 width=1648) + Conds:RS_55._col11, _col0=RS_56._col1, (_col0 - 52)(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12","_col15","_col16","_col17","_col18","_col19","_col20"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_56] + PartitionCols:_col1, (_col0 - 52) + Select Operator [SEL_48] (rows=26628 width=776) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_183] (rows=26628 width=776) + Conds:RS_45._col1=RS_209._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col10"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_209] + PartitionCols:_col0 + Select Operator [SEL_208] (rows=1704 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_207] (rows=1704 width=104) + predicate:(s_store_sk is not null and s_store_id is not null) + TableScan [TS_39] (rows=1704 width=104) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_45] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_182] (rows=26628 width=676) + Conds:RS_206._col0=RS_201._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_201] + PartitionCols:_col0 + Select Operator [SEL_199] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_197] (rows=317 width=8) + predicate:(d_month_seq BETWEEN 1197 AND 1208 and d_week_seq is not null) + TableScan [TS_15] (rows=73049 width=8) + default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_week_seq"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_206] + PartitionCols:_col0 + Group By Operator [GBY_205] (rows=1104768 width=679) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col0, _col1 + Group By Operator [GBY_32] (rows=525329897 width=679) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)","sum(_col3)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 + Select Operator [SEL_30] (rows=525329897 width=138) + Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_181] (rows=525329897 width=138) + Conds:RS_188._col0=RS_193._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_188] + PartitionCols:_col0 + Select Operator [SEL_186] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_185] (rows=525329897 width=114) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_193] + PartitionCols:_col0 + Select Operator [SEL_191] (rows=73049 width=36) + Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_189] (rows=73049 width=99) + predicate:(d_date_sk is not null and d_week_seq is not null) + TableScan [TS_3] (rows=73049 width=99) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq","d_day_name"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_55] + PartitionCols:_col11, _col0 + Merge Join Operator [MERGEJOIN_180] (rows=26628 width=976) + Conds:RS_52._col1=RS_204._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_204] PartitionCols:_col0 - Select Operator [SEL_207] (rows=1704 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_206] (rows=1704 width=104) + Select Operator [SEL_203] (rows=1704 width=192) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_202] (rows=1704 width=192) predicate:(s_store_sk is not null and s_store_id is not null) - TableScan [TS_39] (rows=1704 width=104) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_45] + TableScan [TS_18] (rows=1704 width=192) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_52] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_181] (rows=26628 width=676) - Conds:RS_205._col0=RS_200._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_179] (rows=26628 width=788) + Conds:RS_195._col0=RS_200._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] <-Map 13 [SIMPLE_EDGE] vectorized SHUFFLE [RS_200] PartitionCols:_col0 Select Operator [SEL_198] (rows=317 width=4) Output:["_col0"] Filter Operator [FIL_196] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1197 AND 1208 and d_week_seq is not null) - TableScan [TS_15] (rows=73049 width=8) - default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_week_seq"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_205] + predicate:(d_month_seq BETWEEN 1185 AND 1196 and d_week_seq is not null) + Please refer to the previous TableScan [TS_15] + <-Reducer 3 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_195] PartitionCols:_col0 - Group By Operator [GBY_204] (rows=1104768 width=679) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_33] + Group By Operator [GBY_194] (rows=1104768 width=791) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] PartitionCols:_col0, _col1 - Group By Operator [GBY_32] (rows=525329897 width=679) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col2)","sum(_col3)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 - Select Operator [SEL_30] (rows=525329897 width=138) - Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_180] (rows=525329897 width=138) - Conds:RS_187._col0=RS_192._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col8","_col9","_col10","_col11"] + Group By Operator [GBY_11] (rows=525329897 width=791) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 + Select Operator [SEL_9] (rows=525329897 width=142) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_178] (rows=525329897 width=142) + Conds:RS_187._col0=RS_192._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] <-Map 1 [SIMPLE_EDGE] vectorized SHUFFLE [RS_187] PartitionCols:_col0 - Select Operator [SEL_185] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_184] (rows=525329897 width=114) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_sales_price"] + Please refer to the previous Select Operator [SEL_186] <-Map 12 [SIMPLE_EDGE] vectorized SHUFFLE [RS_192] PartitionCols:_col0 Select Operator [SEL_190] (rows=73049 width=36) - Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_188] (rows=73049 width=99) - predicate:(d_date_sk is not null and d_week_seq is not null) - TableScan [TS_3] (rows=73049 width=99) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq","d_day_name"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_55] - PartitionCols:_col11, _col0 - Merge Join Operator [MERGEJOIN_179] (rows=26628 width=976) - Conds:RS_52._col1=RS_203._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11","_col12"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_203] - PartitionCols:_col0 - Select Operator [SEL_202] (rows=1704 width=192) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_201] (rows=1704 width=192) - predicate:(s_store_sk is not null and s_store_id is not null) - TableScan [TS_18] (rows=1704 width=192) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id","s_store_name"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_52] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_178] (rows=26628 width=788) - Conds:RS_194._col0=RS_199._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_199] - PartitionCols:_col0 - Select Operator [SEL_197] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_195] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1185 AND 1196 and d_week_seq is not null) - Please refer to the previous TableScan [TS_15] - <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_194] - PartitionCols:_col0 - Group By Operator [GBY_193] (rows=1104768 width=791) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0, _col1 - Group By Operator [GBY_11] (rows=525329897 width=791) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col0, _col1 - Select Operator [SEL_9] (rows=525329897 width=142) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Merge Join Operator [MERGEJOIN_177] (rows=525329897 width=142) - Conds:RS_186._col0=RS_191._col0(Inner),Output:["_col1","_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_186] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_185] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_191] - PartitionCols:_col0 - Select Operator [SEL_189] (rows=73049 width=36) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Please refer to the previous Filter Operator [FIL_188] + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Please refer to the previous Filter Operator [FIL_189] diff --git ql/src/test/results/clientpositive/perf/tez/query6.q.out ql/src/test/results/clientpositive/perf/tez/query6.q.out index 5c49ab4517..cae785dac9 100644 --- ql/src/test/results/clientpositive/perf/tez/query6.q.out +++ ql/src/test/results/clientpositive/perf/tez/query6.q.out @@ -1,4 +1,4 @@ -Warning: Map Join MAPJOIN[172][bigTable=?] in task 'Reducer 15' is a cross product +Warning: Map Join MAPJOIN[173][bigTable=?] in task 'Reducer 15' is a cross product PREHOOK: query: explain select a.ca_state state, count(*) cnt from customer_address a @@ -83,158 +83,160 @@ Stage-0 limit:100 Stage-1 Reducer 10 vectorized - File Output Operator [FS_236] - Limit [LIM_235] (rows=17 width=94) + File Output Operator [FS_238] + Limit [LIM_237] (rows=17 width=94) Number of rows:100 - Select Operator [SEL_234] (rows=17 width=94) + Select Operator [SEL_236] (rows=17 width=94) Output:["_col0","_col1"] <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_233] - Filter Operator [FIL_232] (rows=17 width=94) - predicate:(_col1 >= 10L) - Group By Operator [GBY_231] (rows=51 width=94) - Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_70] - PartitionCols:_col0 - Group By Operator [GBY_69] (rows=9027 width=94) - Output:["_col0","_col1"],aggregations:["count()"],keys:_col9 - Merge Join Operator [MERGEJOIN_175] (rows=525327388 width=86) - Conds:RS_65._col4=RS_215._col0(Inner),Output:["_col9"] - <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_215] - PartitionCols:_col0 - Select Operator [SEL_214] (rows=153611 width=227) - Output:["_col0"] - Filter Operator [FIL_213] (rows=153611 width=227) - predicate:(_col4 > _col1) - Map Join Operator [MAPJOIN_212] (rows=460833 width=227) - Conds:RS_209._col0=SEL_211._col2(Inner),Output:["_col1","_col3","_col4"] - <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_209] - PartitionCols:_col0 - Map Join Operator [MAPJOIN_208] (rows=10 width=202) - Conds:(Inner),Output:["_col0","_col1"] - <-Reducer 5 [BROADCAST_EDGE] vectorized - BROADCAST [RS_204] - Select Operator [SEL_203] (rows=1 width=8) - Filter Operator [FIL_202] (rows=1 width=8) - predicate:(sq_count_check(_col0) <= 1) - Group By Operator [GBY_201] (rows=1 width=8) - Output:["_col0"],aggregations:["count(VALUE._col0)"] - <-Reducer 4 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_200] - Group By Operator [GBY_199] (rows=1 width=8) - Output:["_col0"],aggregations:["count()"] - Select Operator [SEL_198] (rows=25 width=4) - Group By Operator [GBY_197] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 2 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_187] - PartitionCols:_col0 - Group By Operator [GBY_185] (rows=25 width=4) - Output:["_col0"],keys:d_month_seq - Select Operator [SEL_183] (rows=50 width=12) - Output:["d_month_seq"] - Filter Operator [FIL_181] (rows=50 width=12) - predicate:((d_year = 2000) and (d_moy = 2)) - TableScan [TS_3] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] - <-Select Operator [SEL_207] (rows=10 width=202) - Output:["_col0","_col1"] - Filter Operator [FIL_206] (rows=10 width=210) - predicate:CAST( (_col1 / _col2) AS decimal(16,6)) is not null - Group By Operator [GBY_205] (rows=10 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_196] + SHUFFLE [RS_235] + Top N Key Operator [TNK_234] (rows=17 width=94) + keys:_col1,top n:100 + Filter Operator [FIL_233] (rows=17 width=94) + predicate:(_col1 >= 10L) + Group By Operator [GBY_232] (rows=51 width=94) + Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_70] + PartitionCols:_col0 + Group By Operator [GBY_69] (rows=9027 width=94) + Output:["_col0","_col1"],aggregations:["count()"],keys:_col9 + Merge Join Operator [MERGEJOIN_176] (rows=525327388 width=86) + Conds:RS_65._col4=RS_216._col0(Inner),Output:["_col9"] + <-Map 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_216] + PartitionCols:_col0 + Select Operator [SEL_215] (rows=153611 width=227) + Output:["_col0"] + Filter Operator [FIL_214] (rows=153611 width=227) + predicate:(_col4 > _col1) + Map Join Operator [MAPJOIN_213] (rows=460833 width=227) + Conds:RS_210._col0=SEL_212._col2(Inner),Output:["_col1","_col3","_col4"] + <-Reducer 15 [BROADCAST_EDGE] vectorized + BROADCAST [RS_210] + PartitionCols:_col0 + Map Join Operator [MAPJOIN_209] (rows=10 width=202) + Conds:(Inner),Output:["_col0","_col1"] + <-Reducer 5 [BROADCAST_EDGE] vectorized + BROADCAST [RS_205] + Select Operator [SEL_204] (rows=1 width=8) + Filter Operator [FIL_203] (rows=1 width=8) + predicate:(sq_count_check(_col0) <= 1) + Group By Operator [GBY_202] (rows=1 width=8) + Output:["_col0"],aggregations:["count(VALUE._col0)"] + <-Reducer 4 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_201] + Group By Operator [GBY_200] (rows=1 width=8) + Output:["_col0"],aggregations:["count()"] + Select Operator [SEL_199] (rows=25 width=4) + Group By Operator [GBY_198] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 2 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_188] + PartitionCols:_col0 + Group By Operator [GBY_186] (rows=25 width=4) + Output:["_col0"],keys:d_month_seq + Select Operator [SEL_184] (rows=50 width=12) + Output:["d_month_seq"] + Filter Operator [FIL_182] (rows=50 width=12) + predicate:((d_year = 2000) and (d_moy = 2)) + TableScan [TS_3] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_month_seq","d_year","d_moy"] + <-Select Operator [SEL_208] (rows=10 width=202) + Output:["_col0","_col1"] + Filter Operator [FIL_207] (rows=10 width=210) + predicate:CAST( (_col1 / _col2) AS decimal(16,6)) is not null + Group By Operator [GBY_206] (rows=10 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0 + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_197] + PartitionCols:_col0 + Group By Operator [GBY_196] (rows=10 width=210) + Output:["_col0","_col1","_col2"],aggregations:["sum(i_current_price)","count(i_current_price)"],keys:i_category + Filter Operator [FIL_195] (rows=462000 width=201) + predicate:i_category is not null + TableScan [TS_23] (rows=462000 width=201) + default@item,j,Tbl:COMPLETE,Col:COMPLETE,Output:["i_current_price","i_category"] + <-Select Operator [SEL_212] (rows=460833 width=205) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_211] (rows=460833 width=205) + predicate:(i_current_price is not null and i_item_sk is not null and i_category is not null) + TableScan [TS_45] (rows=462000 width=205) + default@item,i,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price","i_category"] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_65] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_175] (rows=525327388 width=90) + Conds:RS_225._col5=RS_63._col0(Inner),Output:["_col4","_col9"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_225] + PartitionCols:_col5 + Map Join Operator [MAPJOIN_224] (rows=525327388 width=7) + Conds:RS_194._col0=SEL_223._col0(Inner),Output:["_col4","_col5"] + <-Map 1 [BROADCAST_EDGE] vectorized + BROADCAST [RS_194] + PartitionCols:_col0 + Map Join Operator [MAPJOIN_193] (rows=660 width=4) + Conds:SEL_192._col1=RS_190._col0(Inner),Output:["_col0"] + <-Reducer 3 [BROADCAST_EDGE] vectorized + BROADCAST [RS_190] + PartitionCols:_col0 + Group By Operator [GBY_189] (rows=25 width=4) + Output:["_col0"],keys:KEY._col0 + <-Map 2 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_187] PartitionCols:_col0 - Group By Operator [GBY_195] (rows=10 width=210) - Output:["_col0","_col1","_col2"],aggregations:["sum(i_current_price)","count(i_current_price)"],keys:i_category - Filter Operator [FIL_194] (rows=462000 width=201) - predicate:i_category is not null - TableScan [TS_23] (rows=462000 width=201) - default@item,j,Tbl:COMPLETE,Col:COMPLETE,Output:["i_current_price","i_category"] - <-Select Operator [SEL_211] (rows=460833 width=205) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_210] (rows=460833 width=205) - predicate:(i_current_price is not null and i_item_sk is not null and i_category is not null) - TableScan [TS_45] (rows=462000 width=205) - default@item,i,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price","i_category"] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_65] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_174] (rows=525327388 width=90) - Conds:RS_224._col5=RS_63._col0(Inner),Output:["_col4","_col9"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_224] - PartitionCols:_col5 - Map Join Operator [MAPJOIN_223] (rows=525327388 width=7) - Conds:RS_193._col0=SEL_222._col0(Inner),Output:["_col4","_col5"] - <-Map 1 [BROADCAST_EDGE] vectorized - BROADCAST [RS_193] - PartitionCols:_col0 - Map Join Operator [MAPJOIN_192] (rows=660 width=4) - Conds:SEL_191._col1=RS_189._col0(Inner),Output:["_col0"] - <-Reducer 3 [BROADCAST_EDGE] vectorized - BROADCAST [RS_189] - PartitionCols:_col0 - Group By Operator [GBY_188] (rows=25 width=4) - Output:["_col0"],keys:KEY._col0 - <-Map 2 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_186] - PartitionCols:_col0 - Group By Operator [GBY_184] (rows=25 width=4) - Output:["_col0"],keys:d_month_seq - Select Operator [SEL_182] (rows=50 width=12) - Output:["d_month_seq"] - Filter Operator [FIL_180] (rows=50 width=12) - predicate:((d_year = 2000) and (d_moy = 2) and d_month_seq is not null) - Please refer to the previous TableScan [TS_3] - <-Select Operator [SEL_191] (rows=73049 width=8) + Group By Operator [GBY_185] (rows=25 width=4) + Output:["_col0"],keys:d_month_seq + Select Operator [SEL_183] (rows=50 width=12) + Output:["d_month_seq"] + Filter Operator [FIL_181] (rows=50 width=12) + predicate:((d_year = 2000) and (d_moy = 2) and d_month_seq is not null) + Please refer to the previous TableScan [TS_3] + <-Select Operator [SEL_192] (rows=73049 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_191] (rows=73049 width=8) + predicate:(d_date_sk is not null and d_month_seq is not null) + TableScan [TS_0] (rows=73049 width=8) + default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Select Operator [SEL_223] (rows=525327388 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_222] (rows=525327388 width=11) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_66_i_i_item_sk_min) AND DynamicValue(RS_66_i_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_66_i_i_item_sk_bloom_filter))) + TableScan [TS_10] (rows=575995635 width=11) + default@store_sales,s,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk"] + <-Reducer 17 [BROADCAST_EDGE] vectorized + BROADCAST [RS_221] + Group By Operator [GBY_220] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 16 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_219] + Group By Operator [GBY_218] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_217] (rows=153611 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_215] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_172] (rows=80000000 width=90) + Conds:RS_228._col1=RS_231._col0(Inner),Output:["_col0","_col3"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_228] + PartitionCols:_col1 + Select Operator [SEL_227] (rows=80000000 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_226] (rows=80000000 width=8) + predicate:(c_current_addr_sk is not null and c_customer_sk is not null) + TableScan [TS_13] (rows=80000000 width=8) + default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_231] + PartitionCols:_col0 + Select Operator [SEL_230] (rows=40000000 width=90) Output:["_col0","_col1"] - Filter Operator [FIL_190] (rows=73049 width=8) - predicate:(d_date_sk is not null and d_month_seq is not null) - TableScan [TS_0] (rows=73049 width=8) - default@date_dim,d,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Select Operator [SEL_222] (rows=525327388 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_221] (rows=525327388 width=11) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_66_i_i_item_sk_min) AND DynamicValue(RS_66_i_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_66_i_i_item_sk_bloom_filter))) - TableScan [TS_10] (rows=575995635 width=11) - default@store_sales,s,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk"] - <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_220] - Group By Operator [GBY_219] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 16 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_218] - Group By Operator [GBY_217] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_216] (rows=153611 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_214] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_171] (rows=80000000 width=90) - Conds:RS_227._col1=RS_230._col0(Inner),Output:["_col0","_col3"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_227] - PartitionCols:_col1 - Select Operator [SEL_226] (rows=80000000 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_225] (rows=80000000 width=8) - predicate:(c_current_addr_sk is not null and c_customer_sk is not null) - TableScan [TS_13] (rows=80000000 width=8) - default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_230] - PartitionCols:_col0 - Select Operator [SEL_229] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_228] (rows=40000000 width=90) - predicate:ca_address_sk is not null - TableScan [TS_16] (rows=40000000 width=90) - default@customer_address,a,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] + Filter Operator [FIL_229] (rows=40000000 width=90) + predicate:ca_address_sk is not null + TableScan [TS_16] (rows=40000000 width=90) + default@customer_address,a,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] diff --git ql/src/test/results/clientpositive/perf/tez/query60.q.out ql/src/test/results/clientpositive/perf/tez/query60.q.out index e77c89ba69..8bc53138d3 100644 --- ql/src/test/results/clientpositive/perf/tez/query60.q.out +++ ql/src/test/results/clientpositive/perf/tez/query60.q.out @@ -197,230 +197,232 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_362] - Limit [LIM_361] (rows=100 width=212) + File Output Operator [FS_368] + Limit [LIM_367] (rows=100 width=212) Number of rows:100 - Select Operator [SEL_360] (rows=1717 width=212) + Select Operator [SEL_366] (rows=1717 width=212) Output:["_col0","_col1"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_359] - Group By Operator [GBY_358] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 11 [CONTAINS] vectorized - Reduce Output Operator [RS_380] - PartitionCols:_col0 - Group By Operator [GBY_379] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Top N Key Operator [TNK_378] (rows=5151 width=212) - keys:_col0,top n:100 - Group By Operator [GBY_377] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_109] - PartitionCols:_col0 - Group By Operator [GBY_108] (rows=99586 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_305] (rows=69268204 width=211) - Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_104] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_294] (rows=34340 width=104) - Conds:RS_323._col1=RS_329._col0(Inner),Output:["_col0","_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col1 - Select Operator [SEL_322] (rows=462000 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_321] (rows=462000 width=104) - predicate:(i_item_id is not null and i_item_sk is not null) - TableScan [TS_0] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_329] - PartitionCols:_col0 - Group By Operator [GBY_328] (rows=23100 width=100) - Output:["_col0"],keys:KEY._col0 - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_327] - PartitionCols:_col0 - Group By Operator [GBY_326] (rows=23100 width=100) - Output:["_col0"],keys:i_item_id - Select Operator [SEL_325] (rows=46200 width=190) - Output:["i_item_id"] - Filter Operator [FIL_324] (rows=46200 width=190) - predicate:((i_category = 'Children') and i_item_id is not null) - TableScan [TS_3] (rows=462000 width=190) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_category"] - <-Reducer 23 [SIMPLE_EDGE] - SHUFFLE [RS_105] - PartitionCols:_col2 - Select Operator [SEL_100] (rows=143931246 width=115) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_302] (rows=143931246 width=115) - Conds:RS_97._col2=RS_353._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_353] - PartitionCols:_col0 - Select Operator [SEL_350] (rows=8000000 width=4) - Output:["_col0"] - Filter Operator [FIL_349] (rows=8000000 width=112) - predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) - TableScan [TS_16] (rows=40000000 width=112) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_97] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_301] (rows=143931246 width=119) - Conds:RS_376._col0=RS_336._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_336] - PartitionCols:_col0 - Select Operator [SEL_331] (rows=50 width=4) - Output:["_col0"] - Filter Operator [FIL_330] (rows=50 width=12) - predicate:((d_year = 1999) and (d_moy = 9) and d_date_sk is not null) - TableScan [TS_13] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_376] - PartitionCols:_col0 - Select Operator [SEL_375] (rows=143931246 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_374] (rows=143931246 width=123) - predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_85] (rows=144002668 width=123) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_373] - Group By Operator [GBY_372] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_343] - Group By Operator [GBY_340] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_337] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_331] - <-Reducer 4 [CONTAINS] vectorized - Reduce Output Operator [RS_357] - PartitionCols:_col0 - Group By Operator [GBY_356] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Top N Key Operator [TNK_355] (rows=5151 width=212) - keys:_col0,top n:100 - Group By Operator [GBY_354] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_34] - PartitionCols:_col0 - Group By Operator [GBY_33] (rows=343400 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_303] (rows=252818424 width=201) - Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_29] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_294] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col2 - Select Operator [SEL_25] (rows=525327191 width=110) - Output:["_col2","_col4"] - Merge Join Operator [MERGEJOIN_296] (rows=525327191 width=110) - Conds:RS_22._col2=RS_351._col0(Inner),Output:["_col1","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_351] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_350] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_295] (rows=525327191 width=114) - Conds:RS_348._col0=RS_332._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_332] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_331] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Select Operator [SEL_347] (rows=525327191 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_346] (rows=525327191 width=118) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_10] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] - <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_345] - Group By Operator [GBY_344] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_341] - Group By Operator [GBY_338] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_333] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_331] - <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_371] - PartitionCols:_col0 - Group By Operator [GBY_370] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Top N Key Operator [TNK_369] (rows=5151 width=212) - keys:_col0,top n:100 - Group By Operator [GBY_368] (rows=1717 width=212) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_71] - PartitionCols:_col0 - Group By Operator [GBY_70] (rows=195738 width=212) - Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 - Merge Join Operator [MERGEJOIN_304] (rows=137215467 width=210) - Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_294] - <-Reducer 20 [SIMPLE_EDGE] - SHUFFLE [RS_67] - PartitionCols:_col3 - Select Operator [SEL_62] (rows=285117733 width=115) - Output:["_col3","_col4"] - Merge Join Operator [MERGEJOIN_299] (rows=285117733 width=115) - Conds:RS_59._col1=RS_352._col0(Inner),Output:["_col2","_col3"] - <-Map 25 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_352] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_350] - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_59] + SHUFFLE [RS_365] + Top N Key Operator [TNK_364] (rows=1717 width=212) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_363] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 11 [CONTAINS] vectorized + Reduce Output Operator [RS_386] + PartitionCols:_col0 + Group By Operator [GBY_385] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Top N Key Operator [TNK_384] (rows=5151 width=212) + keys:_col0,top n:100 + Group By Operator [GBY_383] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_109] + PartitionCols:_col0 + Group By Operator [GBY_108] (rows=99586 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_310] (rows=69268204 width=211) + Conds:RS_104._col0=RS_105._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_104] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_299] (rows=34340 width=104) + Conds:RS_328._col1=RS_334._col0(Inner),Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_328] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_298] (rows=285117733 width=119) - Conds:RS_367._col0=RS_334._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 17 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_334] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_331] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_367] + Select Operator [SEL_327] (rows=462000 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_326] (rows=462000 width=104) + predicate:(i_item_id is not null and i_item_sk is not null) + TableScan [TS_0] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_334] + PartitionCols:_col0 + Group By Operator [GBY_333] (rows=23100 width=100) + Output:["_col0"],keys:KEY._col0 + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_332] PartitionCols:_col0 - Select Operator [SEL_366] (rows=285117733 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_365] (rows=285117733 width=123) - predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_47] (rows=287989836 width=123) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] - <-Reducer 21 [BROADCAST_EDGE] vectorized - BROADCAST [RS_364] - Group By Operator [GBY_363] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_342] - Group By Operator [GBY_339] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_335] (rows=50 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_331] + Group By Operator [GBY_331] (rows=23100 width=100) + Output:["_col0"],keys:i_item_id + Select Operator [SEL_330] (rows=46200 width=190) + Output:["i_item_id"] + Filter Operator [FIL_329] (rows=46200 width=190) + predicate:((i_category = 'Children') and i_item_id is not null) + TableScan [TS_3] (rows=462000 width=190) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_id","i_category"] + <-Reducer 23 [SIMPLE_EDGE] + SHUFFLE [RS_105] + PartitionCols:_col2 + Select Operator [SEL_100] (rows=143931246 width=115) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_307] (rows=143931246 width=115) + Conds:RS_97._col2=RS_358._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_358] + PartitionCols:_col0 + Select Operator [SEL_355] (rows=8000000 width=4) + Output:["_col0"] + Filter Operator [FIL_354] (rows=8000000 width=112) + predicate:((ca_gmt_offset = -6) and ca_address_sk is not null) + TableScan [TS_16] (rows=40000000 width=112) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_gmt_offset"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_97] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_306] (rows=143931246 width=119) + Conds:RS_382._col0=RS_341._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_341] + PartitionCols:_col0 + Select Operator [SEL_336] (rows=50 width=4) + Output:["_col0"] + Filter Operator [FIL_335] (rows=50 width=12) + predicate:((d_year = 1999) and (d_moy = 9) and d_date_sk is not null) + TableScan [TS_13] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Map 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_382] + PartitionCols:_col0 + Select Operator [SEL_381] (rows=143931246 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_380] (rows=143931246 width=123) + predicate:(ws_sold_date_sk is not null and ws_bill_addr_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_95_date_dim_d_date_sk_min) AND DynamicValue(RS_95_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_95_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_85] (rows=144002668 width=123) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_addr_sk","ws_ext_sales_price"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_379] + Group By Operator [GBY_378] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_348] + Group By Operator [GBY_345] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_342] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_336] + <-Reducer 4 [CONTAINS] vectorized + Reduce Output Operator [RS_362] + PartitionCols:_col0 + Group By Operator [GBY_361] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Top N Key Operator [TNK_360] (rows=5151 width=212) + keys:_col0,top n:100 + Group By Operator [GBY_359] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_34] + PartitionCols:_col0 + Group By Operator [GBY_33] (rows=343400 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_308] (rows=252818424 width=201) + Conds:RS_29._col0=RS_30._col2(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_29] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_299] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col2 + Select Operator [SEL_25] (rows=525327191 width=110) + Output:["_col2","_col4"] + Merge Join Operator [MERGEJOIN_301] (rows=525327191 width=110) + Conds:RS_22._col2=RS_356._col0(Inner),Output:["_col1","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_356] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_355] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_300] (rows=525327191 width=114) + Conds:RS_353._col0=RS_337._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_337] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_336] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_353] + PartitionCols:_col0 + Select Operator [SEL_352] (rows=525327191 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_351] (rows=525327191 width=118) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_20_date_dim_d_date_sk_min) AND DynamicValue(RS_20_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_20_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_10] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] + <-Reducer 18 [BROADCAST_EDGE] vectorized + BROADCAST [RS_350] + Group By Operator [GBY_349] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_346] + Group By Operator [GBY_343] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_338] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_336] + <-Reducer 9 [CONTAINS] vectorized + Reduce Output Operator [RS_377] + PartitionCols:_col0 + Group By Operator [GBY_376] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Top N Key Operator [TNK_375] (rows=5151 width=212) + keys:_col0,top n:100 + Group By Operator [GBY_374] (rows=1717 width=212) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_71] + PartitionCols:_col0 + Group By Operator [GBY_70] (rows=195738 width=212) + Output:["_col0","_col1"],aggregations:["sum(_col7)"],keys:_col1 + Merge Join Operator [MERGEJOIN_309] (rows=137215467 width=210) + Conds:RS_66._col0=RS_67._col3(Inner),Output:["_col1","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_299] + <-Reducer 20 [SIMPLE_EDGE] + SHUFFLE [RS_67] + PartitionCols:_col3 + Select Operator [SEL_62] (rows=285117733 width=115) + Output:["_col3","_col4"] + Merge Join Operator [MERGEJOIN_304] (rows=285117733 width=115) + Conds:RS_59._col1=RS_357._col0(Inner),Output:["_col2","_col3"] + <-Map 25 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_357] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_355] + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_59] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_303] (rows=285117733 width=119) + Conds:RS_373._col0=RS_339._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 17 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_339] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_336] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_373] + PartitionCols:_col0 + Select Operator [SEL_372] (rows=285117733 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_371] (rows=285117733 width=123) + predicate:(cs_sold_date_sk is not null and cs_bill_addr_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_57_date_dim_d_date_sk_min) AND DynamicValue(RS_57_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_57_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_47] (rows=287989836 width=123) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_addr_sk","cs_item_sk","cs_ext_sales_price"] + <-Reducer 21 [BROADCAST_EDGE] vectorized + BROADCAST [RS_370] + Group By Operator [GBY_369] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_347] + Group By Operator [GBY_344] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_340] (rows=50 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_336] diff --git ql/src/test/results/clientpositive/perf/tez/query63.q.out ql/src/test/results/clientpositive/perf/tez/query63.q.out index 3cdf37b734..99ab75982c 100644 --- ql/src/test/results/clientpositive/perf/tez/query63.q.out +++ ql/src/test/results/clientpositive/perf/tez/query63.q.out @@ -80,87 +80,89 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_106] - Limit [LIM_105] (rows=100 width=228) + File Output Operator [FS_107] + Limit [LIM_106] (rows=100 width=228) Number of rows:100 - Select Operator [SEL_104] (rows=338 width=228) + Select Operator [SEL_105] (rows=338 width=228) Output:["_col0","_col1","_col2"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_33] Select Operator [SEL_30] (rows=338 width=228) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_46] (rows=338 width=228) - predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END - Select Operator [SEL_29] (rows=676 width=116) - Output:["avg_window_0","_col0","_col2"] - PTF Operator [PTF_28] (rows=676 width=116) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] - Select Operator [SEL_25] (rows=676 width=116) - Output:["_col0","_col2"] - Group By Operator [GBY_24] (rows=676 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0 - Group By Operator [GBY_22] (rows=676 width=120) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col5, _col7 - Merge Join Operator [MERGEJOIN_84] (rows=569118 width=8) - Conds:RS_18._col2=RS_101._col0(Inner),Output:["_col3","_col5","_col7"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_101] - PartitionCols:_col0 - Select Operator [SEL_100] (rows=1704 width=4) - Output:["_col0"] - Filter Operator [FIL_99] (rows=1704 width=4) - predicate:s_store_sk is not null - TableScan [TS_9] (rows=1704 width=4) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_83] (rows=569118 width=8) - Conds:RS_15._col0=RS_98._col0(Inner),Output:["_col2","_col3","_col5","_col7"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_98] - PartitionCols:_col0 - Select Operator [SEL_97] (rows=317 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_96] (rows=317 width=12) - predicate:((d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_moy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_82] (rows=569118 width=4) - Conds:RS_95._col1=RS_87._col0(Inner),Output:["_col0","_col2","_col3","_col5"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_87] - PartitionCols:_col0 - Select Operator [SEL_86] (rows=52 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_85] (rows=52 width=290) - predicate:((i_class) IN ('personal', 'portable', 'refernece', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'refernece', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1'))) and i_item_sk is not null) - TableScan [TS_3] (rows=462000 width=289) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manager_id"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_95] - PartitionCols:_col1 - Select Operator [SEL_94] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_93] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_13_item_i_item_sk_min) AND DynamicValue(RS_13_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_13_item_i_item_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_92] - Group By Operator [GBY_91] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_90] - Group By Operator [GBY_89] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_88] (rows=52 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_86] + Top N Key Operator [TNK_52] (rows=338 width=228) + keys:_col0, avg_window_0, _col2,top n:100 + Filter Operator [FIL_46] (rows=338 width=228) + predicate:CASE WHEN ((avg_window_0 > 0)) THEN (((abs((_col2 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END + Select Operator [SEL_29] (rows=676 width=116) + Output:["avg_window_0","_col0","_col2"] + PTF Operator [PTF_28] (rows=676 width=116) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col0 ASC NULLS FIRST","partition by:":"_col0"}] + Select Operator [SEL_25] (rows=676 width=116) + Output:["_col0","_col2"] + Group By Operator [GBY_24] (rows=676 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0 + Group By Operator [GBY_22] (rows=676 width=120) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col5, _col7 + Merge Join Operator [MERGEJOIN_85] (rows=569118 width=8) + Conds:RS_18._col2=RS_102._col0(Inner),Output:["_col3","_col5","_col7"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_102] + PartitionCols:_col0 + Select Operator [SEL_101] (rows=1704 width=4) + Output:["_col0"] + Filter Operator [FIL_100] (rows=1704 width=4) + predicate:s_store_sk is not null + TableScan [TS_9] (rows=1704 width=4) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_84] (rows=569118 width=8) + Conds:RS_15._col0=RS_99._col0(Inner),Output:["_col2","_col3","_col5","_col7"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_99] + PartitionCols:_col0 + Select Operator [SEL_98] (rows=317 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_97] (rows=317 width=12) + predicate:((d_month_seq) IN (1212, 1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 1221, 1222, 1223) and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_moy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_83] (rows=569118 width=4) + Conds:RS_96._col1=RS_88._col0(Inner),Output:["_col0","_col2","_col3","_col5"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_88] + PartitionCols:_col0 + Select Operator [SEL_87] (rows=52 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_86] (rows=52 width=290) + predicate:((i_class) IN ('personal', 'portable', 'refernece', 'self-help', 'accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9', 'amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1') and (i_category) IN ('Books', 'Children', 'Electronics', 'Women', 'Music', 'Men') and (((i_category) IN ('Books', 'Children', 'Electronics') and (i_class) IN ('personal', 'portable', 'refernece', 'self-help') and (i_brand) IN ('scholaramalgamalg #14', 'scholaramalgamalg #7', 'exportiunivamalg #9', 'scholaramalgamalg #9')) or ((i_category) IN ('Women', 'Music', 'Men') and (i_class) IN ('accessories', 'classical', 'fragrances', 'pants') and (i_brand) IN ('amalgimporto #1', 'edu packscholar #1', 'exportiimporto #1', 'importoamalg #1'))) and i_item_sk is not null) + TableScan [TS_3] (rows=462000 width=289) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_manager_id"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_96] + PartitionCols:_col1 + Select Operator [SEL_95] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_94] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_13_item_i_item_sk_min) AND DynamicValue(RS_13_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_13_item_i_item_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_93] + Group By Operator [GBY_92] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_91] + Group By Operator [GBY_90] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_89] (rows=52 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_87] diff --git ql/src/test/results/clientpositive/perf/tez/query65.q.out ql/src/test/results/clientpositive/perf/tez/query65.q.out index dbc5c79a87..18455836da 100644 --- ql/src/test/results/clientpositive/perf/tez/query65.q.out +++ ql/src/test/results/clientpositive/perf/tez/query65.q.out @@ -83,120 +83,122 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_172] - Limit [LIM_171] (rows=100 width=708) + File Output Operator [FS_173] + Limit [LIM_172] (rows=100 width=708) Number of rows:100 - Select Operator [SEL_170] (rows=1772841 width=707) + Select Operator [SEL_171] (rows=1772841 width=707) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_53] Select Operator [SEL_52] (rows=1772841 width=707) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_139] (rows=1772841 width=707) - Conds:RS_49._col1=RS_169._col0(Inner),Output:["_col2","_col6","_col8","_col9","_col10","_col11"] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_169] - PartitionCols:_col0 - Select Operator [SEL_168] (rows=462000 width=511) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_167] (rows=462000 width=511) - predicate:i_item_sk is not null - TableScan [TS_39] (rows=462000 width=511) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc","i_current_price","i_wholesale_cost","i_brand"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_49] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_138] (rows=1772841 width=204) - Conds:RS_46._col0=RS_166._col0(Inner),Output:["_col1","_col2","_col6"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_166] - PartitionCols:_col0 - Select Operator [SEL_165] (rows=1704 width=92) - Output:["_col0","_col1"] - Filter Operator [FIL_164] (rows=1704 width=92) - predicate:s_store_sk is not null - TableScan [TS_36] (rows=1704 width=92) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_46] - PartitionCols:_col0 - Filter Operator [FIL_45] (rows=1772841 width=231) - predicate:(_col2 <= _col4) - Merge Join Operator [MERGEJOIN_137] (rows=5318523 width=231) - Conds:RS_157._col0=RS_163._col0(Inner),Output:["_col0","_col1","_col2","_col4"] - <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_157] - PartitionCols:_col0 - Filter Operator [FIL_156] (rows=5255208 width=119) - predicate:_col2 is not null - Group By Operator [GBY_155] (rows=5255208 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_11] - PartitionCols:_col0, _col1 - Group By Operator [GBY_10] (rows=525329897 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_135] (rows=525329897 width=114) - Conds:RS_153._col0=RS_142._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_142] - PartitionCols:_col0 - Select Operator [SEL_141] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_140] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_153] - PartitionCols:_col0 - Select Operator [SEL_151] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_149] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 11 [BROADCAST_EDGE] vectorized - BROADCAST [RS_148] - Group By Operator [GBY_147] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - Group By Operator [GBY_145] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_143] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_141] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] - PartitionCols:_col0 - Select Operator [SEL_162] (rows=84 width=115) - Output:["_col0","_col1"] - Filter Operator [FIL_161] (rows=84 width=123) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_160] (rows=84 width=123) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 - Select Operator [SEL_159] (rows=5255208 width=119) - Output:["_col1","_col2"] - Group By Operator [GBY_158] (rows=5255208 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col0 - Group By Operator [GBY_26] (rows=525329897 width=119) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 - Merge Join Operator [MERGEJOIN_136] (rows=525329897 width=114) - Conds:RS_154._col0=RS_144._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_141] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_154] - PartitionCols:_col0 - Select Operator [SEL_152] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_150] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) - Please refer to the previous TableScan [TS_0] + Top N Key Operator [TNK_82] (rows=1772841 width=707) + keys:_col6, _col8,top n:100 + Merge Join Operator [MERGEJOIN_140] (rows=1772841 width=707) + Conds:RS_49._col1=RS_170._col0(Inner),Output:["_col2","_col6","_col8","_col9","_col10","_col11"] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_170] + PartitionCols:_col0 + Select Operator [SEL_169] (rows=462000 width=511) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_168] (rows=462000 width=511) + predicate:i_item_sk is not null + TableScan [TS_39] (rows=462000 width=511) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc","i_current_price","i_wholesale_cost","i_brand"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_49] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_139] (rows=1772841 width=204) + Conds:RS_46._col0=RS_167._col0(Inner),Output:["_col1","_col2","_col6"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_167] + PartitionCols:_col0 + Select Operator [SEL_166] (rows=1704 width=92) + Output:["_col0","_col1"] + Filter Operator [FIL_165] (rows=1704 width=92) + predicate:s_store_sk is not null + TableScan [TS_36] (rows=1704 width=92) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_46] + PartitionCols:_col0 + Filter Operator [FIL_45] (rows=1772841 width=231) + predicate:(_col2 <= _col4) + Merge Join Operator [MERGEJOIN_138] (rows=5318523 width=231) + Conds:RS_158._col0=RS_164._col0(Inner),Output:["_col0","_col1","_col2","_col4"] + <-Reducer 3 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_158] + PartitionCols:_col0 + Filter Operator [FIL_157] (rows=5255208 width=119) + predicate:_col2 is not null + Group By Operator [GBY_156] (rows=5255208 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_11] + PartitionCols:_col0, _col1 + Group By Operator [GBY_10] (rows=525329897 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_136] (rows=525329897 width=114) + Conds:RS_154._col0=RS_143._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_143] + PartitionCols:_col0 + Select Operator [SEL_142] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_141] (rows=317 width=8) + predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_154] + PartitionCols:_col0 + Select Operator [SEL_152] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_150] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 11 [BROADCAST_EDGE] vectorized + BROADCAST [RS_149] + Group By Operator [GBY_148] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 10 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_147] + Group By Operator [GBY_146] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_144] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_142] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_164] + PartitionCols:_col0 + Select Operator [SEL_163] (rows=84 width=115) + Output:["_col0","_col1"] + Filter Operator [FIL_162] (rows=84 width=123) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_161] (rows=84 width=123) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col1 + Select Operator [SEL_160] (rows=5255208 width=119) + Output:["_col1","_col2"] + Group By Operator [GBY_159] (rows=5255208 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col0 + Group By Operator [GBY_26] (rows=525329897 width=119) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col2, _col1 + Merge Join Operator [MERGEJOIN_137] (rows=525329897 width=114) + Conds:RS_155._col0=RS_145._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_145] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_142] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_155] + PartitionCols:_col0 + Select Operator [SEL_153] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_151] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_7_date_dim_d_date_sk_min) AND DynamicValue(RS_7_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_7_date_dim_d_date_sk_bloom_filter))) + Please refer to the previous TableScan [TS_0] diff --git ql/src/test/results/clientpositive/perf/tez/query66.q.out ql/src/test/results/clientpositive/perf/tez/query66.q.out index 7ddcc21f92..0c4b12b72f 100644 --- ql/src/test/results/clientpositive/perf/tez/query66.q.out +++ ql/src/test/results/clientpositive/perf/tez/query66.q.out @@ -479,28 +479,28 @@ Stage-0 limit:-1 Stage-1 Reducer 9 vectorized - File Output Operator [FS_254] - Select Operator [SEL_253] (rows=100 width=4614) + File Output Operator [FS_259] + Select Operator [SEL_258] (rows=100 width=4614) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41","_col42","_col43"] - Limit [LIM_252] (rows=100 width=4510) + Limit [LIM_257] (rows=100 width=4510) Number of rows:100 - Select Operator [SEL_251] (rows=2423925 width=4510) + Select Operator [SEL_256] (rows=2423925 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_250] - Group By Operator [GBY_249] (rows=2423925 width=4510) + SHUFFLE [RS_255] + Group By Operator [GBY_254] (rows=2423925 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)","sum(VALUE._col24)","sum(VALUE._col25)","sum(VALUE._col26)","sum(VALUE._col27)","sum(VALUE._col28)","sum(VALUE._col29)","sum(VALUE._col30)","sum(VALUE._col31)","sum(VALUE._col32)","sum(VALUE._col33)","sum(VALUE._col34)","sum(VALUE._col35)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Union 7 [SIMPLE_EDGE] <-Reducer 15 [CONTAINS] vectorized - Reduce Output Operator [RS_264] + Reduce Output Operator [RS_269] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_263] (rows=2513727 width=4510) + Group By Operator [GBY_268] (rows=2513727 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Top N Key Operator [TNK_262] (rows=2513727 width=3166) - keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 - Select Operator [SEL_261] (rows=2513727 width=3166) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] - Group By Operator [GBY_260] (rows=2513700 width=3166) + Select Operator [SEL_267] (rows=2513727 width=3166) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] + Top N Key Operator [TNK_266] (rows=2513727 width=3166) + keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 + Group By Operator [GBY_265] (rows=2513700 width=3166) Output:["_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"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_63] @@ -509,89 +509,89 @@ Stage-0 Output:["_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"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 Select Operator [SEL_60] (rows=15681803 width=750) Output:["_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"] - Merge Join Operator [MERGEJOIN_204] (rows=15681803 width=750) - Conds:RS_57._col3=RS_243._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] + Merge Join Operator [MERGEJOIN_209] (rows=15681803 width=750) + Conds:RS_57._col3=RS_248._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_243] + SHUFFLE [RS_248] PartitionCols:_col0 - Select Operator [SEL_241] (rows=27 width=482) + Select Operator [SEL_246] (rows=27 width=482) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_240] (rows=27 width=482) + Filter Operator [FIL_245] (rows=27 width=482) predicate:w_warehouse_sk is not null TableScan [TS_12] (rows=27 width=482) default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name","w_warehouse_sq_ft","w_city","w_county","w_state","w_country"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_203] (rows=15681803 width=275) - Conds:RS_54._col2=RS_221._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_208] (rows=15681803 width=275) + Conds:RS_54._col2=RS_226._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_221] + SHUFFLE [RS_226] PartitionCols:_col0 - Select Operator [SEL_218] (rows=1 width=4) + Select Operator [SEL_223] (rows=1 width=4) Output:["_col0"] - Filter Operator [FIL_217] (rows=1 width=88) + Filter Operator [FIL_222] (rows=1 width=88) predicate:((sm_carrier) IN ('DIAMOND', 'AIRBORNE') and sm_ship_mode_sk is not null) TableScan [TS_9] (rows=1 width=88) default@ship_mode,ship_mode,Tbl:COMPLETE,Col:COMPLETE,Output:["sm_ship_mode_sk","sm_carrier"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_54] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_202] (rows=282272460 width=279) - Conds:RS_51._col0=RS_239._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_207] (rows=282272460 width=279) + Conds:RS_51._col0=RS_244._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_239] + SHUFFLE [RS_244] PartitionCols:_col0 - Select Operator [SEL_237] (rows=652 width=52) + Select Operator [SEL_242] (rows=652 width=52) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - Filter Operator [FIL_236] (rows=652 width=12) + Filter Operator [FIL_241] (rows=652 width=12) predicate:((d_year = 2002) and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_51] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_201] (rows=282272460 width=235) - Conds:RS_259._col1=RS_235._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_206] (rows=282272460 width=235) + Conds:RS_264._col1=RS_240._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_235] + SHUFFLE [RS_240] PartitionCols:_col0 - Select Operator [SEL_233] (rows=33426 width=4) + Select Operator [SEL_238] (rows=33426 width=4) Output:["_col0"] - Filter Operator [FIL_232] (rows=33426 width=8) + Filter Operator [FIL_237] (rows=33426 width=8) predicate:(t_time BETWEEN 49530 AND 78330 and t_time_sk is not null) TableScan [TS_3] (rows=86400 width=8) default@time_dim,time_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["t_time_sk","t_time"] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_259] + SHUFFLE [RS_264] PartitionCols:_col1 - Select Operator [SEL_258] (rows=282272460 width=239) + Select Operator [SEL_263] (rows=282272460 width=239) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_257] (rows=282272460 width=243) + Filter Operator [FIL_262] (rows=282272460 width=243) predicate:(cs_warehouse_sk is not null and cs_sold_date_sk is not null and cs_sold_time_sk is not null and cs_ship_mode_sk is not null and cs_ship_mode_sk BETWEEN DynamicValue(RS_55_ship_mode_sm_ship_mode_sk_min) AND DynamicValue(RS_55_ship_mode_sm_ship_mode_sk_max) and in_bloom_filter(cs_ship_mode_sk, DynamicValue(RS_55_ship_mode_sm_ship_mode_sk_bloom_filter))) TableScan [TS_33] (rows=287989836 width=243) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_sold_time_sk","cs_ship_mode_sk","cs_warehouse_sk","cs_quantity","cs_ext_sales_price","cs_net_paid_inc_ship_tax"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_256] - Group By Operator [GBY_255] (rows=1 width=12) + BROADCAST [RS_261] + Group By Operator [GBY_260] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_226] - Group By Operator [GBY_224] (rows=1 width=12) + SHUFFLE [RS_231] + Group By Operator [GBY_229] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_222] (rows=1 width=4) + Select Operator [SEL_227] (rows=1 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_218] + Please refer to the previous Select Operator [SEL_223] <-Reducer 6 [CONTAINS] vectorized - Reduce Output Operator [RS_248] + Reduce Output Operator [RS_253] PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_247] (rows=2513727 width=4510) + Group By Operator [GBY_252] (rows=2513727 width=4510) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)","sum(_col30)","sum(_col31)","sum(_col32)","sum(_col33)","sum(_col34)","sum(_col35)","sum(_col36)","sum(_col37)","sum(_col38)","sum(_col39)","sum(_col40)","sum(_col41)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Top N Key Operator [TNK_246] (rows=2513727 width=3166) - keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 - Select Operator [SEL_245] (rows=2513727 width=3166) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] - Group By Operator [GBY_244] (rows=27 width=3166) + Select Operator [SEL_251] (rows=2513727 width=3166) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col20","_col21","_col22","_col23","_col24","_col25","_col26","_col27","_col28","_col29","_col30","_col31","_col32","_col33","_col34","_col35","_col36","_col37","_col38","_col39","_col40","_col41"] + Top N Key Operator [TNK_250] (rows=2513727 width=3166) + keys:_col0, _col1, _col2, _col3, _col4, _col5,top n:100 + Group By Operator [GBY_249] (rows=27 width=3166) Output:["_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"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)","sum(VALUE._col5)","sum(VALUE._col6)","sum(VALUE._col7)","sum(VALUE._col8)","sum(VALUE._col9)","sum(VALUE._col10)","sum(VALUE._col11)","sum(VALUE._col12)","sum(VALUE._col13)","sum(VALUE._col14)","sum(VALUE._col15)","sum(VALUE._col16)","sum(VALUE._col17)","sum(VALUE._col18)","sum(VALUE._col19)","sum(VALUE._col20)","sum(VALUE._col21)","sum(VALUE._col22)","sum(VALUE._col23)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_30] @@ -600,57 +600,57 @@ Stage-0 Output:["_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"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)","sum(_col9)","sum(_col10)","sum(_col11)","sum(_col12)","sum(_col13)","sum(_col14)","sum(_col15)","sum(_col16)","sum(_col17)","sum(_col18)","sum(_col19)","sum(_col20)","sum(_col21)","sum(_col22)","sum(_col23)","sum(_col24)","sum(_col25)","sum(_col26)","sum(_col27)","sum(_col28)","sum(_col29)"],keys:_col0, _col1, _col2, _col3, _col4, _col5 Select Operator [SEL_27] (rows=7992175 width=750) Output:["_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"] - Merge Join Operator [MERGEJOIN_200] (rows=7992175 width=750) - Conds:RS_24._col3=RS_242._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] + Merge Join Operator [MERGEJOIN_205] (rows=7992175 width=750) + Conds:RS_24._col3=RS_247._col0(Inner),Output:["_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19","_col22","_col23","_col24","_col25","_col26","_col27"] <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_242] + SHUFFLE [RS_247] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_241] + Please refer to the previous Select Operator [SEL_246] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_199] (rows=7992175 width=275) - Conds:RS_21._col2=RS_219._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_204] (rows=7992175 width=275) + Conds:RS_21._col2=RS_224._col0(Inner),Output:["_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_219] + SHUFFLE [RS_224] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_218] + Please refer to the previous Select Operator [SEL_223] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_198] (rows=143859154 width=279) - Conds:RS_18._col0=RS_238._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] + Merge Join Operator [MERGEJOIN_203] (rows=143859154 width=279) + Conds:RS_18._col0=RS_243._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col17","_col18","_col19"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_238] + SHUFFLE [RS_243] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_237] + Please refer to the previous Select Operator [SEL_242] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_197] (rows=143859154 width=235) - Conds:RS_231._col1=RS_234._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_202] (rows=143859154 width=235) + Conds:RS_236._col1=RS_239._col0(Inner),Output:["_col0","_col2","_col3","_col4","_col5"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_234] + SHUFFLE [RS_239] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_233] + Please refer to the previous Select Operator [SEL_238] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_231] + SHUFFLE [RS_236] PartitionCols:_col1 - Select Operator [SEL_230] (rows=143859154 width=239) + Select Operator [SEL_235] (rows=143859154 width=239) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_229] (rows=143859154 width=243) + Filter Operator [FIL_234] (rows=143859154 width=243) predicate:(ws_sold_time_sk is not null and ws_warehouse_sk is not null and ws_sold_date_sk is not null and ws_ship_mode_sk is not null and ws_ship_mode_sk BETWEEN DynamicValue(RS_22_ship_mode_sm_ship_mode_sk_min) AND DynamicValue(RS_22_ship_mode_sm_ship_mode_sk_max) and in_bloom_filter(ws_ship_mode_sk, DynamicValue(RS_22_ship_mode_sm_ship_mode_sk_bloom_filter))) TableScan [TS_0] (rows=144002668 width=243) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_sold_time_sk","ws_ship_mode_sk","ws_warehouse_sk","ws_quantity","ws_sales_price","ws_net_paid_inc_tax"] <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_228] - Group By Operator [GBY_227] (rows=1 width=12) + BROADCAST [RS_233] + Group By Operator [GBY_232] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 17 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] - Group By Operator [GBY_223] (rows=1 width=12) + SHUFFLE [RS_230] + Group By Operator [GBY_228] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_220] (rows=1 width=4) + Select Operator [SEL_225] (rows=1 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_218] + Please refer to the previous Select Operator [SEL_223] diff --git ql/src/test/results/clientpositive/perf/tez/query67.q.out ql/src/test/results/clientpositive/perf/tez/query67.q.out index cbacaae150..54d76e9c1a 100644 --- ql/src/test/results/clientpositive/perf/tez/query67.q.out +++ ql/src/test/results/clientpositive/perf/tez/query67.q.out @@ -111,90 +111,92 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_111] - Limit [LIM_110] (rows=100 width=617) + File Output Operator [FS_113] + Limit [LIM_112] (rows=100 width=617) Number of rows:100 - Select Operator [SEL_109] (rows=1575989691 width=617) + Select Operator [SEL_111] (rows=1575989691 width=617) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_108] - Select Operator [SEL_107] (rows=1575989691 width=617) + SHUFFLE [RS_110] + Select Operator [SEL_109] (rows=1575989691 width=617) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Filter Operator [FIL_106] (rows=1575989691 width=613) - predicate:(rank_window_0 <= 100) - PTF Operator [PTF_105] (rows=4727969073 width=613) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col8 DESC NULLS LAST","partition by:":"_col2"}] - Select Operator [SEL_104] (rows=4727969073 width=613) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_103] - PartitionCols:_col2 - Select Operator [SEL_102] (rows=4727969073 width=613) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Group By Operator [GBY_101] (rows=4727969073 width=621) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, KEY._col8 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 - Group By Operator [GBY_22] (rows=4727969073 width=621) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"],aggregations:["sum(_col3)"],keys:_col11, _col12, _col13, _col14, _col5, _col6, _col7, _col9, 0L - Merge Join Operator [MERGEJOIN_83] (rows=525329897 width=613) - Conds:RS_18._col1=RS_100._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12","_col13","_col14"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_100] - PartitionCols:_col0 - Select Operator [SEL_99] (rows=462000 width=393) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_98] (rows=462000 width=393) - predicate:i_item_sk is not null - TableScan [TS_9] (rows=462000 width=393) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_82] (rows=525329897 width=228) - Conds:RS_15._col2=RS_97._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col9"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_97] - PartitionCols:_col0 - Select Operator [SEL_96] (rows=1704 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_95] (rows=1704 width=104) - predicate:s_store_sk is not null - TableScan [TS_6] (rows=1704 width=104) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_81] (rows=525329897 width=131) - Conds:RS_94._col0=RS_86._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] - <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_86] - PartitionCols:_col0 - Select Operator [SEL_85] (rows=317 width=16) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_84] (rows=317 width=20) - predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=20) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_year","d_moy","d_qoy"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_94] - PartitionCols:_col0 - Select Operator [SEL_93] (rows=525329897 width=123) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_92] (rows=525329897 width=122) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_quantity","ss_sales_price"] - <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_91] - Group By Operator [GBY_90] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_89] - Group By Operator [GBY_88] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_87] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_85] + Top N Key Operator [TNK_108] (rows=1575989691 width=613) + keys:_col2, _col1, _col0, _col3, _col4, _col6, _col5, _col7, _col8, rank_window_0,top n:100 + Filter Operator [FIL_107] (rows=1575989691 width=613) + predicate:(rank_window_0 <= 100) + PTF Operator [PTF_106] (rows=4727969073 width=613) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col8 DESC NULLS LAST","partition by:":"_col2"}] + Select Operator [SEL_105] (rows=4727969073 width=613) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_104] + PartitionCols:_col2 + Select Operator [SEL_103] (rows=4727969073 width=613) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Group By Operator [GBY_102] (rows=4727969073 width=621) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5, KEY._col6, KEY._col7, KEY._col8 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8 + Group By Operator [GBY_22] (rows=4727969073 width=621) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"],aggregations:["sum(_col3)"],keys:_col11, _col12, _col13, _col14, _col5, _col6, _col7, _col9, 0L + Merge Join Operator [MERGEJOIN_84] (rows=525329897 width=613) + Conds:RS_18._col1=RS_101._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12","_col13","_col14"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_101] + PartitionCols:_col0 + Select Operator [SEL_100] (rows=462000 width=393) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_99] (rows=462000 width=393) + predicate:i_item_sk is not null + TableScan [TS_9] (rows=462000 width=393) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category","i_product_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_83] (rows=525329897 width=228) + Conds:RS_15._col2=RS_98._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col9"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_98] + PartitionCols:_col0 + Select Operator [SEL_97] (rows=1704 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_96] (rows=1704 width=104) + predicate:s_store_sk is not null + TableScan [TS_6] (rows=1704 width=104) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_82] (rows=525329897 width=131) + Conds:RS_95._col0=RS_87._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7"] + <-Map 8 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_87] + PartitionCols:_col0 + Select Operator [SEL_86] (rows=317 width=16) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_85] (rows=317 width=20) + predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=20) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq","d_year","d_moy","d_qoy"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_95] + PartitionCols:_col0 + Select Operator [SEL_94] (rows=525329897 width=123) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_93] (rows=525329897 width=122) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_quantity","ss_sales_price"] + <-Reducer 9 [BROADCAST_EDGE] vectorized + BROADCAST [RS_92] + Group By Operator [GBY_91] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_90] + Group By Operator [GBY_89] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_88] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_86] diff --git ql/src/test/results/clientpositive/perf/tez/query68.q.out ql/src/test/results/clientpositive/perf/tez/query68.q.out index b9321679a9..fab21efc20 100644 --- ql/src/test/results/clientpositive/perf/tez/query68.q.out +++ ql/src/test/results/clientpositive/perf/tez/query68.q.out @@ -113,120 +113,122 @@ Stage-0 limit:100 Stage-1 Reducer 4 vectorized - File Output Operator [FS_175] - Limit [LIM_174] (rows=100 width=706) + File Output Operator [FS_176] + Limit [LIM_175] (rows=100 width=706) Number of rows:100 - Select Operator [SEL_173] (rows=457565061 width=706) + Select Operator [SEL_174] (rows=457565061 width=706) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_46] Select Operator [SEL_45] (rows=457565061 width=706) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_44] (rows=457565061 width=706) - predicate:(_col5 <> _col8) - Merge Join Operator [MERGEJOIN_145] (rows=457565061 width=706) - Conds:RS_41._col0=RS_172._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10","_col11"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_41] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_140] (rows=80000000 width=277) - Conds:RS_148._col1=RS_151._col0(Inner),Output:["_col0","_col2","_col3","_col5"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_151] - PartitionCols:_col0 - Select Operator [SEL_150] (rows=40000000 width=97) - Output:["_col0","_col1"] - Filter Operator [FIL_149] (rows=40000000 width=97) - predicate:ca_address_sk is not null - TableScan [TS_3] (rows=40000000 width=97) - default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col1 - Select Operator [SEL_147] (rows=80000000 width=188) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_146] (rows=80000000 width=188) - predicate:(c_customer_sk is not null and c_current_addr_sk is not null) - TableScan [TS_0] (rows=80000000 width=188) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] - <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_172] - PartitionCols:_col1 - Select Operator [SEL_171] (rows=457565061 width=436) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_170] (rows=457565061 width=440) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_35] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_34] (rows=457565061 width=440) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col1, _col13, _col3, _col5 - Merge Join Operator [MERGEJOIN_144] (rows=457565061 width=425) - Conds:RS_30._col3=RS_152._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col13"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_152] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_150] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=332) - Conds:RS_27._col2=RS_169._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_169] - PartitionCols:_col0 - Select Operator [SEL_168] (rows=1855 width=4) - Output:["_col0"] - Filter Operator [FIL_167] (rows=1855 width=12) - predicate:(((hd_dep_count = 2) or (hd_vehicle_count = 1)) and hd_demo_sk is not null) - TableScan [TS_15] (rows=7200 width=12) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=336) - Conds:RS_24._col4=RS_166._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_166] - PartitionCols:_col0 - Select Operator [SEL_165] (rows=14 width=4) - Output:["_col0"] - Filter Operator [FIL_164] (rows=14 width=97) - predicate:((s_city) IN ('Cedar Grove', 'Wildwood') and s_store_sk is not null) - TableScan [TS_12] (rows=1704 width=97) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_141] (rows=457565061 width=340) - Conds:RS_163._col0=RS_155._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_155] - PartitionCols:_col0 - Select Operator [SEL_154] (rows=170 width=4) - Output:["_col0"] - Filter Operator [FIL_153] (rows=170 width=12) - predicate:(d_dom BETWEEN 1 AND 2 and (d_year) IN (1998, 1999, 2000) and d_date_sk is not null) - TableScan [TS_9] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dom"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_163] - PartitionCols:_col0 - Select Operator [SEL_162] (rows=457565061 width=343) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_161] (rows=457565061 width=343) - predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_6] (rows=575995635 width=343) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_ext_sales_price","ss_ext_list_price","ss_ext_tax"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_160] - Group By Operator [GBY_159] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_158] - Group By Operator [GBY_157] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_156] (rows=170 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_154] + Top N Key Operator [TNK_80] (rows=457565061 width=706) + keys:_col3, _col6,top n:100 + Filter Operator [FIL_44] (rows=457565061 width=706) + predicate:(_col5 <> _col8) + Merge Join Operator [MERGEJOIN_146] (rows=457565061 width=706) + Conds:RS_41._col0=RS_173._col1(Inner),Output:["_col2","_col3","_col5","_col6","_col8","_col9","_col10","_col11"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_41] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_141] (rows=80000000 width=277) + Conds:RS_149._col1=RS_152._col0(Inner),Output:["_col0","_col2","_col3","_col5"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_152] + PartitionCols:_col0 + Select Operator [SEL_151] (rows=40000000 width=97) + Output:["_col0","_col1"] + Filter Operator [FIL_150] (rows=40000000 width=97) + predicate:ca_address_sk is not null + TableScan [TS_3] (rows=40000000 width=97) + default@customer_address,current_addr,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col1 + Select Operator [SEL_148] (rows=80000000 width=188) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_147] (rows=80000000 width=188) + predicate:(c_customer_sk is not null and c_current_addr_sk is not null) + TableScan [TS_0] (rows=80000000 width=188) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_addr_sk","c_first_name","c_last_name"] + <-Reducer 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_173] + PartitionCols:_col1 + Select Operator [SEL_172] (rows=457565061 width=436) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Group By Operator [GBY_171] (rows=457565061 width=440) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_35] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_34] (rows=457565061 width=440) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col1, _col13, _col3, _col5 + Merge Join Operator [MERGEJOIN_145] (rows=457565061 width=425) + Conds:RS_30._col3=RS_153._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col13"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_153] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_151] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_144] (rows=457565061 width=332) + Conds:RS_27._col2=RS_170._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_170] + PartitionCols:_col0 + Select Operator [SEL_169] (rows=1855 width=4) + Output:["_col0"] + Filter Operator [FIL_168] (rows=1855 width=12) + predicate:(((hd_dep_count = 2) or (hd_vehicle_count = 1)) and hd_demo_sk is not null) + TableScan [TS_15] (rows=7200 width=12) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_143] (rows=457565061 width=336) + Conds:RS_24._col4=RS_167._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_167] + PartitionCols:_col0 + Select Operator [SEL_166] (rows=14 width=4) + Output:["_col0"] + Filter Operator [FIL_165] (rows=14 width=97) + predicate:((s_city) IN ('Cedar Grove', 'Wildwood') and s_store_sk is not null) + TableScan [TS_12] (rows=1704 width=97) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_city"] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_142] (rows=457565061 width=340) + Conds:RS_164._col0=RS_156._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_156] + PartitionCols:_col0 + Select Operator [SEL_155] (rows=170 width=4) + Output:["_col0"] + Filter Operator [FIL_154] (rows=170 width=12) + predicate:(d_dom BETWEEN 1 AND 2 and (d_year) IN (1998, 1999, 2000) and d_date_sk is not null) + TableScan [TS_9] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dom"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_164] + PartitionCols:_col0 + Select Operator [SEL_163] (rows=457565061 width=343) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_162] (rows=457565061 width=343) + predicate:(ss_sold_date_sk is not null and ss_addr_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_6] (rows=575995635 width=343) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_ext_sales_price","ss_ext_list_price","ss_ext_tax"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_161] + Group By Operator [GBY_160] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_159] + Group By Operator [GBY_158] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_157] (rows=170 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_155] diff --git ql/src/test/results/clientpositive/perf/tez/query69.q.out ql/src/test/results/clientpositive/perf/tez/query69.q.out index d11b5494e0..16bf1f599c 100644 --- ql/src/test/results/clientpositive/perf/tez/query69.q.out +++ ql/src/test/results/clientpositive/perf/tez/query69.q.out @@ -133,30 +133,30 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_231] - Limit [LIM_230] (rows=1 width=383) + File Output Operator [FS_236] + Limit [LIM_235] (rows=1 width=383) Number of rows:100 - Select Operator [SEL_229] (rows=1 width=383) + Select Operator [SEL_234] (rows=1 width=383) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_228] - Select Operator [SEL_227] (rows=1 width=383) + SHUFFLE [RS_233] + Select Operator [SEL_232] (rows=1 width=383) Output:["_col0","_col1","_col2","_col3","_col4","_col6"] - Group By Operator [GBY_226] (rows=1 width=367) + Group By Operator [GBY_231] (rows=1 width=367) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_69] PartitionCols:_col0, _col1, _col2, _col3, _col4 Group By Operator [GBY_68] (rows=1 width=367) Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count()"],keys:_col6, _col7, _col8, _col9, _col10 - Top N Key Operator [TNK_105] (rows=1 width=363) - keys:_col6, _col7, _col8, _col9, _col10,top n:100 - Select Operator [SEL_67] (rows=1 width=363) - Output:["_col6","_col7","_col8","_col9","_col10"] + Select Operator [SEL_67] (rows=1 width=363) + Output:["_col6","_col7","_col8","_col9","_col10"] + Top N Key Operator [TNK_108] (rows=1 width=363) + keys:_col6, _col7, _col8, _col9, _col10,top n:100 Filter Operator [FIL_66] (rows=1 width=363) predicate:_col13 is null - Merge Join Operator [MERGEJOIN_184] (rows=1401496 width=363) - Conds:RS_63._col0=RS_225._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col13"] + Merge Join Operator [MERGEJOIN_189] (rows=1401496 width=363) + Conds:RS_63._col0=RS_230._col1(Left Outer),Output:["_col6","_col7","_col8","_col9","_col10","_col13"] <-Reducer 5 [SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_63] PartitionCols:_col0 @@ -164,55 +164,55 @@ Stage-0 Output:["_col0","_col6","_col7","_col8","_col9","_col10"] Filter Operator [FIL_47] (rows=1 width=367) predicate:_col11 is null - Merge Join Operator [MERGEJOIN_183] (rows=1414922 width=367) - Conds:RS_44._col0=RS_217._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11"] + Merge Join Operator [MERGEJOIN_188] (rows=1414922 width=367) + Conds:RS_44._col0=RS_222._col1(Left Outer),Output:["_col0","_col6","_col7","_col8","_col9","_col10","_col11"] <-Reducer 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_217] + SHUFFLE [RS_222] PartitionCols:_col1 - Select Operator [SEL_216] (rows=1414922 width=7) + Select Operator [SEL_221] (rows=1414922 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_215] (rows=1414922 width=3) + Group By Operator [GBY_220] (rows=1414922 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col0 Group By Operator [GBY_29] (rows=143930993 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_180] (rows=143930993 width=3) - Conds:RS_214._col0=RS_198._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_185] (rows=143930993 width=3) + Conds:RS_219._col0=RS_203._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_198] + SHUFFLE [RS_203] PartitionCols:_col0 - Select Operator [SEL_195] (rows=150 width=4) + Select Operator [SEL_200] (rows=150 width=4) Output:["_col0"] - Filter Operator [FIL_194] (rows=150 width=12) + Filter Operator [FIL_199] (rows=150 width=12) predicate:((d_year = 1999) and d_moy BETWEEN 1 AND 3 and d_date_sk is not null) TableScan [TS_12] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_214] + SHUFFLE [RS_219] PartitionCols:_col0 - Select Operator [SEL_213] (rows=143930993 width=7) + Select Operator [SEL_218] (rows=143930993 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_212] (rows=143930993 width=7) + Filter Operator [FIL_217] (rows=143930993 width=7) predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_26_date_dim_d_date_sk_min) AND DynamicValue(RS_26_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_26_date_dim_d_date_sk_bloom_filter))) TableScan [TS_19] (rows=144002668 width=7) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk"] <-Reducer 18 [BROADCAST_EDGE] vectorized - BROADCAST [RS_211] - Group By Operator [GBY_210] (rows=1 width=12) + BROADCAST [RS_216] + Group By Operator [GBY_215] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_204] - Group By Operator [GBY_202] (rows=1 width=12) + SHUFFLE [RS_209] + Group By Operator [GBY_207] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_199] (rows=150 width=4) + Select Operator [SEL_204] (rows=150 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_195] + Please refer to the previous Select Operator [SEL_200] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_44] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_182] (rows=525327388 width=363) + Merge Join Operator [MERGEJOIN_187] (rows=525327388 width=363) Conds:RS_41._col0=RS_42._col0(Left Semi),Output:["_col0","_col6","_col7","_col8","_col9","_col10"] <-Reducer 13 [SIMPLE_EDGE] SHUFFLE [RS_42] @@ -221,105 +221,105 @@ Stage-0 Output:["_col0"],keys:_col0 Select Operator [SEL_18] (rows=525327388 width=3) Output:["_col0"] - Merge Join Operator [MERGEJOIN_179] (rows=525327388 width=3) - Conds:RS_209._col0=RS_196._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_184] (rows=525327388 width=3) + Conds:RS_214._col0=RS_201._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_196] + SHUFFLE [RS_201] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_195] + Please refer to the previous Select Operator [SEL_200] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_209] + SHUFFLE [RS_214] PartitionCols:_col0 - Select Operator [SEL_208] (rows=525327388 width=7) + Select Operator [SEL_213] (rows=525327388 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_207] (rows=525327388 width=7) + Filter Operator [FIL_212] (rows=525327388 width=7) predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) TableScan [TS_9] (rows=575995635 width=7) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk"] <-Reducer 15 [BROADCAST_EDGE] vectorized - BROADCAST [RS_206] - Group By Operator [GBY_205] (rows=1 width=12) + BROADCAST [RS_211] + Group By Operator [GBY_210] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 14 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_203] - Group By Operator [GBY_201] (rows=1 width=12) + SHUFFLE [RS_208] + Group By Operator [GBY_206] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_197] (rows=150 width=4) + Select Operator [SEL_202] (rows=150 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_195] + Please refer to the previous Select Operator [SEL_200] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_41] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_178] (rows=4605476 width=363) - Conds:RS_36._col1=RS_193._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10"] + Merge Join Operator [MERGEJOIN_183] (rows=4605476 width=363) + Conds:RS_36._col1=RS_198._col0(Inner),Output:["_col0","_col6","_col7","_col8","_col9","_col10"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_193] + SHUFFLE [RS_198] PartitionCols:_col0 - Select Operator [SEL_192] (rows=1861800 width=363) + Select Operator [SEL_197] (rows=1861800 width=363) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_191] (rows=1861800 width=363) + Filter Operator [FIL_196] (rows=1861800 width=363) predicate:cd_demo_sk is not null TableScan [TS_6] (rows=1861800 width=363) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status","cd_purchase_estimate","cd_credit_rating"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_36] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_177] (rows=4541258 width=5) - Conds:RS_187._col2=RS_190._col0(Inner),Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_182] (rows=4541258 width=5) + Conds:RS_192._col2=RS_195._col0(Inner),Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_187] + SHUFFLE [RS_192] PartitionCols:_col2 - Select Operator [SEL_186] (rows=77201384 width=11) + Select Operator [SEL_191] (rows=77201384 width=11) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_185] (rows=77201384 width=11) + Filter Operator [FIL_190] (rows=77201384 width=11) predicate:(c_current_cdemo_sk is not null and c_current_addr_sk is not null and c_customer_sk is not null) TableScan [TS_0] (rows=80000000 width=11) default@customer,c,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_current_cdemo_sk","c_current_addr_sk"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_190] + SHUFFLE [RS_195] PartitionCols:_col0 - Select Operator [SEL_189] (rows=2352941 width=90) + Select Operator [SEL_194] (rows=2352941 width=90) Output:["_col0"] - Filter Operator [FIL_188] (rows=2352941 width=90) + Filter Operator [FIL_193] (rows=2352941 width=90) predicate:((ca_state) IN ('CO', 'IL', 'MN') and ca_address_sk is not null) TableScan [TS_3] (rows=40000000 width=90) default@customer_address,ca,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] + SHUFFLE [RS_230] PartitionCols:_col1 - Select Operator [SEL_224] (rows=1401496 width=7) + Select Operator [SEL_229] (rows=1401496 width=7) Output:["_col0","_col1"] - Group By Operator [GBY_223] (rows=1401496 width=3) + Group By Operator [GBY_228] (rows=1401496 width=3) Output:["_col0"],keys:KEY._col0 <-Reducer 19 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 Group By Operator [GBY_59] (rows=285115246 width=3) Output:["_col0"],keys:_col1 - Merge Join Operator [MERGEJOIN_181] (rows=285115246 width=3) - Conds:RS_222._col0=RS_200._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_186] (rows=285115246 width=3) + Conds:RS_227._col0=RS_205._col0(Inner),Output:["_col1"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_200] + SHUFFLE [RS_205] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_195] + Please refer to the previous Select Operator [SEL_200] <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_222] + SHUFFLE [RS_227] PartitionCols:_col0 - Select Operator [SEL_221] (rows=285115246 width=7) + Select Operator [SEL_226] (rows=285115246 width=7) Output:["_col0","_col1"] - Filter Operator [FIL_220] (rows=285115246 width=7) + Filter Operator [FIL_225] (rows=285115246 width=7) predicate:(cs_ship_customer_sk is not null and cs_sold_date_sk is not null and cs_ship_customer_sk BETWEEN DynamicValue(RS_63_c_c_customer_sk_min) AND DynamicValue(RS_63_c_c_customer_sk_max) and in_bloom_filter(cs_ship_customer_sk, DynamicValue(RS_63_c_c_customer_sk_bloom_filter))) TableScan [TS_49] (rows=287989836 width=7) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_customer_sk"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_219] - Group By Operator [GBY_218] (rows=1 width=12) + BROADCAST [RS_224] + Group By Operator [GBY_223] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Reducer 5 [CUSTOM_SIMPLE_EDGE] - PARTITION_ONLY_SHUFFLE [RS_168] - Group By Operator [GBY_167] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_173] + Group By Operator [GBY_172] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_166] (rows=1 width=4) + Select Operator [SEL_171] (rows=1 width=4) Output:["_col0"] Please refer to the previous Select Operator [SEL_48] diff --git ql/src/test/results/clientpositive/perf/tez/query7.q.out ql/src/test/results/clientpositive/perf/tez/query7.q.out index c17ec8aeb9..2679b52b8e 100644 --- ql/src/test/results/clientpositive/perf/tez/query7.q.out +++ ql/src/test/results/clientpositive/perf/tez/query7.q.out @@ -67,95 +67,95 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_125] - Limit [LIM_124] (rows=100 width=444) + File Output Operator [FS_130] + Limit [LIM_129] (rows=100 width=444) Number of rows:100 - Select Operator [SEL_123] (rows=310774 width=444) + Select Operator [SEL_128] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_122] - Select Operator [SEL_121] (rows=310774 width=444) + SHUFFLE [RS_127] + Select Operator [SEL_126] (rows=310774 width=444) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_120] (rows=310774 width=476) + Group By Operator [GBY_125] (rows=310774 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)","sum(VALUE._col6)","count(VALUE._col7)"],keys:KEY._col0 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0 Group By Operator [GBY_28] (rows=462000 width=476) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"],aggregations:["sum(_col4)","count(_col4)","sum(_col5)","count(_col5)","sum(_col7)","count(_col7)","sum(_col6)","count(_col6)"],keys:_col12 - Top N Key Operator [TNK_55] (rows=4635977 width=100) + Top N Key Operator [TNK_58] (rows=4635977 width=100) keys:_col12,top n:100 - Merge Join Operator [MERGEJOIN_99] (rows=4635977 width=100) - Conds:RS_24._col1=RS_119._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] + Merge Join Operator [MERGEJOIN_104] (rows=4635977 width=100) + Conds:RS_24._col1=RS_124._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col12"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_119] + SHUFFLE [RS_124] PartitionCols:_col0 - Select Operator [SEL_118] (rows=462000 width=104) + Select Operator [SEL_123] (rows=462000 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_117] (rows=462000 width=104) + Filter Operator [FIL_122] (rows=462000 width=104) predicate:i_item_sk is not null TableScan [TS_12] (rows=462000 width=104) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_98] (rows=4635977 width=4) - Conds:RS_21._col3=RS_116._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_103] (rows=4635977 width=4) + Conds:RS_21._col3=RS_121._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_116] + SHUFFLE [RS_121] PartitionCols:_col0 - Select Operator [SEL_115] (rows=2300 width=4) + Select Operator [SEL_120] (rows=2300 width=4) Output:["_col0"] - Filter Operator [FIL_114] (rows=2300 width=174) + Filter Operator [FIL_119] (rows=2300 width=174) predicate:(((p_channel_email = 'N') or (p_channel_event = 'N')) and p_promo_sk is not null) TableScan [TS_9] (rows=2300 width=174) default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_email","p_channel_event"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_97] (rows=4635977 width=4) - Conds:RS_18._col0=RS_113._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_102] (rows=4635977 width=4) + Conds:RS_18._col0=RS_118._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_113] + SHUFFLE [RS_118] PartitionCols:_col0 - Select Operator [SEL_112] (rows=652 width=4) + Select Operator [SEL_117] (rows=652 width=4) Output:["_col0"] - Filter Operator [FIL_111] (rows=652 width=8) + Filter Operator [FIL_116] (rows=652 width=8) predicate:((d_year = 1998) and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_96] (rows=4635977 width=4) - Conds:RS_110._col2=RS_102._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] + Merge Join Operator [MERGEJOIN_101] (rows=4635977 width=4) + Conds:RS_115._col2=RS_107._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7"] <-Map 8 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_102] + PARTITION_ONLY_SHUFFLE [RS_107] PartitionCols:_col0 - Select Operator [SEL_101] (rows=14776 width=4) + Select Operator [SEL_106] (rows=14776 width=4) Output:["_col0"] - Filter Operator [FIL_100] (rows=14776 width=268) + Filter Operator [FIL_105] (rows=14776 width=268) predicate:((cd_marital_status = 'W') and (cd_education_status = 'Primary') and (cd_gender = 'F') and cd_demo_sk is not null) TableScan [TS_3] (rows=1861800 width=268) default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_gender","cd_marital_status","cd_education_status"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_110] + SHUFFLE [RS_115] PartitionCols:_col2 - Select Operator [SEL_109] (rows=501686735 width=340) + Select Operator [SEL_114] (rows=501686735 width=340) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_108] (rows=501686735 width=340) + Filter Operator [FIL_113] (rows=501686735 width=340) predicate:(ss_cdemo_sk is not null and ss_sold_date_sk is not null and ss_promo_sk is not null and ss_item_sk is not null and ss_cdemo_sk BETWEEN DynamicValue(RS_16_customer_demographics_cd_demo_sk_min) AND DynamicValue(RS_16_customer_demographics_cd_demo_sk_max) and in_bloom_filter(ss_cdemo_sk, DynamicValue(RS_16_customer_demographics_cd_demo_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=340) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_cdemo_sk","ss_promo_sk","ss_quantity","ss_list_price","ss_sales_price","ss_coupon_amt"] <-Reducer 9 [BROADCAST_EDGE] vectorized - BROADCAST [RS_107] - Group By Operator [GBY_106] (rows=1 width=12) + BROADCAST [RS_112] + Group By Operator [GBY_111] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 8 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_105] - Group By Operator [GBY_104] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_110] + Group By Operator [GBY_109] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_103] (rows=14776 width=4) + Select Operator [SEL_108] (rows=14776 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_101] + Please refer to the previous Select Operator [SEL_106] diff --git ql/src/test/results/clientpositive/perf/tez/query70.q.out ql/src/test/results/clientpositive/perf/tez/query70.q.out index 7fe3a62399..23f9166a4f 100644 --- ql/src/test/results/clientpositive/perf/tez/query70.q.out +++ ql/src/test/results/clientpositive/perf/tez/query70.q.out @@ -100,117 +100,119 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_168] - Limit [LIM_167] (rows=100 width=492) + File Output Operator [FS_170] + Limit [LIM_169] (rows=100 width=492) Number of rows:100 - Select Operator [SEL_166] (rows=720 width=492) + Select Operator [SEL_168] (rows=720 width=492) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_165] - Select Operator [SEL_164] (rows=720 width=492) + SHUFFLE [RS_167] + Select Operator [SEL_166] (rows=720 width=492) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_163] (rows=720 width=304) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] - Select Operator [SEL_162] (rows=720 width=304) - Output:["_col0","_col1","_col2","_col3"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_161] - PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END - Select Operator [SEL_160] (rows=720 width=304) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_159] (rows=720 width=304) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_49] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_48] (rows=135360 width=304) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L - Select Operator [SEL_46] (rows=171536292 width=280) - Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_134] (rows=171536292 width=280) - Conds:RS_43._col7=RS_158._col0(Inner),Output:["_col2","_col6","_col7"] - <-Reducer 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_158] - PartitionCols:_col0 - Select Operator [SEL_157] (rows=16 width=86) - Output:["_col0"] - Filter Operator [FIL_156] (rows=16 width=198) - predicate:(rank_window_0 <= 5) - PTF Operator [PTF_155] (rows=49 width=198) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"_col0"}] - Select Operator [SEL_154] (rows=49 width=198) - Output:["_col0","_col1"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_153] - PartitionCols:_col0 - Group By Operator [GBY_152] (rows=49 width=198) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_26] - PartitionCols:_col0 - Group By Operator [GBY_25] (rows=19404 width=198) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col5 - Merge Join Operator [MERGEJOIN_133] (rows=525329897 width=192) - Conds:RS_21._col1=RS_151._col0(Inner),Output:["_col2","_col5"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_130] (rows=525329897 width=110) - Conds:RS_145._col0=RS_137._col0(Inner),Output:["_col1","_col2"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_137] - PartitionCols:_col0 - Select Operator [SEL_136] (rows=317 width=8) - Output:["_col0"] - Filter Operator [FIL_135] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_145] - PartitionCols:_col0 - Select Operator [SEL_144] (rows=525329897 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_143] (rows=525329897 width=114) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_38_d1_d_date_sk_min) AND DynamicValue(RS_38_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_38_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_net_profit"] - <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_142] - Group By Operator [GBY_141] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_140] - Group By Operator [GBY_139] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_138] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_136] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_151] - PartitionCols:_col0 - Select Operator [SEL_150] (rows=1704 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_149] (rows=1704 width=90) - predicate:(s_store_sk is not null and s_state is not null) - TableScan [TS_15] (rows=1704 width=90) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_43] - PartitionCols:_col7 - Merge Join Operator [MERGEJOIN_131] (rows=525329897 width=290) - Conds:RS_40._col1=RS_148._col0(Inner),Output:["_col2","_col6","_col7"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col1 - Please refer to the previous Merge Join Operator [MERGEJOIN_130] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_148] - PartitionCols:_col0 - Select Operator [SEL_147] (rows=1704 width=188) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_146] (rows=1704 width=188) - predicate:(s_state is not null and s_store_sk is not null) - TableScan [TS_6] (rows=1704 width=188) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_county","s_state"] + Top N Key Operator [TNK_165] (rows=720 width=304) + keys:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN (((grouping(_col3, 1L) + grouping(_col3, 0L)) = 0L)) THEN (_col0) ELSE (null) END, rank_window_0,top n:100 + PTF Operator [PTF_164] (rows=720 width=304) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] + Select Operator [SEL_163] (rows=720 width=304) + Output:["_col0","_col1","_col2","_col3"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_162] + PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END + Select Operator [SEL_161] (rows=720 width=304) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_160] (rows=720 width=304) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_49] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_48] (rows=135360 width=304) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L + Select Operator [SEL_46] (rows=171536292 width=280) + Output:["_col0","_col1","_col2"] + Merge Join Operator [MERGEJOIN_135] (rows=171536292 width=280) + Conds:RS_43._col7=RS_159._col0(Inner),Output:["_col2","_col6","_col7"] + <-Reducer 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_159] + PartitionCols:_col0 + Select Operator [SEL_158] (rows=16 width=86) + Output:["_col0"] + Filter Operator [FIL_157] (rows=16 width=198) + predicate:(rank_window_0 <= 5) + PTF Operator [PTF_156] (rows=49 width=198) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col1 DESC NULLS LAST","partition by:":"_col0"}] + Select Operator [SEL_155] (rows=49 width=198) + Output:["_col0","_col1"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_154] + PartitionCols:_col0 + Group By Operator [GBY_153] (rows=49 width=198) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_26] + PartitionCols:_col0 + Group By Operator [GBY_25] (rows=19404 width=198) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col5 + Merge Join Operator [MERGEJOIN_134] (rows=525329897 width=192) + Conds:RS_21._col1=RS_152._col0(Inner),Output:["_col2","_col5"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_131] (rows=525329897 width=110) + Conds:RS_146._col0=RS_138._col0(Inner),Output:["_col1","_col2"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_138] + PartitionCols:_col0 + Select Operator [SEL_137] (rows=317 width=8) + Output:["_col0"] + Filter Operator [FIL_136] (rows=317 width=8) + predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_146] + PartitionCols:_col0 + Select Operator [SEL_145] (rows=525329897 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_144] (rows=525329897 width=114) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_38_d1_d_date_sk_min) AND DynamicValue(RS_38_d1_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_38_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_net_profit"] + <-Reducer 12 [BROADCAST_EDGE] vectorized + BROADCAST [RS_143] + Group By Operator [GBY_142] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_141] + Group By Operator [GBY_140] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_139] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_137] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_152] + PartitionCols:_col0 + Select Operator [SEL_151] (rows=1704 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_150] (rows=1704 width=90) + predicate:(s_store_sk is not null and s_state is not null) + TableScan [TS_15] (rows=1704 width=90) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_state"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_43] + PartitionCols:_col7 + Merge Join Operator [MERGEJOIN_132] (rows=525329897 width=290) + Conds:RS_40._col1=RS_149._col0(Inner),Output:["_col2","_col6","_col7"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col1 + Please refer to the previous Merge Join Operator [MERGEJOIN_131] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_149] + PartitionCols:_col0 + Select Operator [SEL_148] (rows=1704 width=188) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_147] (rows=1704 width=188) + predicate:(s_state is not null and s_store_sk is not null) + TableScan [TS_6] (rows=1704 width=188) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_county","s_state"] diff --git ql/src/test/results/clientpositive/perf/tez/query72.q.out ql/src/test/results/clientpositive/perf/tez/query72.q.out index bebc3852b7..9121488b03 100644 --- ql/src/test/results/clientpositive/perf/tez/query72.q.out +++ ql/src/test/results/clientpositive/perf/tez/query72.q.out @@ -101,185 +101,187 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_295] - Limit [LIM_294] (rows=100 width=312) + File Output Operator [FS_297] + Limit [LIM_296] (rows=100 width=312) Number of rows:100 - Select Operator [SEL_293] (rows=690341337 width=312) + Select Operator [SEL_295] (rows=690341337 width=312) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_292] - Group By Operator [GBY_291] (rows=690341337 width=312) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)","count(VALUE._col1)","count(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_70] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_69] (rows=2958149194 width=312) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(_col3)","count(_col4)","count()"],keys:_col0, _col1, _col2 - Select Operator [SEL_67] (rows=7629034847 width=292) - Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_252] (rows=7629034847 width=292) - Conds:RS_64._col4, _col6=RS_290._col0, _col1(Left Outer),Output:["_col13","_col15","_col19","_col25"] - <-Map 24 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_290] - PartitionCols:_col0, _col1 - Select Operator [SEL_289] (rows=28798881 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_288] (rows=28798881 width=8) - predicate:(cr_item_sk is not null and cr_order_number is not null) - TableScan [TS_61] (rows=28798881 width=8) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_64] - PartitionCols:_col4, _col6 - Select Operator [SEL_60] (rows=2958149194 width=300) - Output:["_col4","_col6","_col13","_col15","_col19","_col25"] - Merge Join Operator [MERGEJOIN_251] (rows=2958149194 width=300) - Conds:RS_57._col0, _col19=RS_287._col0, _col1(Inner),Output:["_col5","_col9","_col14","_col16","_col19","_col23"] - <-Map 23 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_287] - PartitionCols:_col0, _col1 - Select Operator [SEL_286] (rows=73049 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_285] (rows=73049 width=8) - predicate:(d_date_sk is not null and d_week_seq is not null) - TableScan [TS_47] (rows=73049 width=8) - default@date_dim,d2,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_57] - PartitionCols:_col0, _col19 - Filter Operator [FIL_56] (rows=2645646117 width=311) - predicate:(_col3 < _col17) - Merge Join Operator [MERGEJOIN_250] (rows=7936938353 width=311) - Conds:RS_53._col1=RS_54._col8(Inner),Output:["_col0","_col3","_col5","_col9","_col14","_col16","_col17","_col19","_col23"] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_54] - PartitionCols:_col8 - Select Operator [SEL_46] (rows=13907708 width=219) - Output:["_col3","_col8","_col10","_col11","_col13","_col17"] - Filter Operator [FIL_45] (rows=13907708 width=219) - predicate:(_col17 > _col10) - Merge Join Operator [MERGEJOIN_249] (rows=41723124 width=219) - Conds:RS_42._col1=RS_284._col0(Inner),Output:["_col4","_col6","_col7","_col9","_col10","_col13","_col15","_col17"] - <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_284] - PartitionCols:_col0 - Select Operator [SEL_283] (rows=73049 width=12) - Output:["_col0","_col1"] - Filter Operator [FIL_282] (rows=73049 width=98) - predicate:(d_date_sk is not null and UDFToDouble(d_date) is not null) - TableScan [TS_24] (rows=73049 width=98) - default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_42] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_248] (rows=41723124 width=215) - Conds:RS_39._col4=RS_281._col0(Inner),Output:["_col1","_col4","_col6","_col7","_col9","_col10","_col13","_col15"] - <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_281] - PartitionCols:_col0 - Select Operator [SEL_280] (rows=462000 width=188) - Output:["_col0","_col1"] - Filter Operator [FIL_279] (rows=462000 width=188) - predicate:i_item_sk is not null - TableScan [TS_21] (rows=462000 width=188) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc"] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_39] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_247] (rows=41723124 width=31) - Conds:RS_36._col5=RS_278._col0(Left Outer),Output:["_col1","_col4","_col6","_col7","_col9","_col10","_col13"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_278] - PartitionCols:_col0 - Select Operator [SEL_277] (rows=2300 width=4) - Output:["_col0"] - Filter Operator [FIL_276] (rows=2300 width=4) - predicate:p_promo_sk is not null - TableScan [TS_18] (rows=2300 width=4) - default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_36] - PartitionCols:_col5 - Merge Join Operator [MERGEJOIN_246] (rows=41723124 width=31) - Conds:RS_33._col3=RS_275._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col9","_col10"] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_275] - PartitionCols:_col0 - Select Operator [SEL_274] (rows=1440 width=4) - Output:["_col0"] - Filter Operator [FIL_273] (rows=1440 width=96) - predicate:((hd_buy_potential = '1001-5000') and hd_demo_sk is not null) - TableScan [TS_15] (rows=7200 width=96) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_buy_potential"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_245] (rows=41723124 width=35) - Conds:RS_30._col2=RS_272._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10"] - <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_272] - PartitionCols:_col0 - Select Operator [SEL_271] (rows=265971 width=4) - Output:["_col0"] - Filter Operator [FIL_270] (rows=265971 width=89) - predicate:((cd_marital_status = 'M') and cd_demo_sk is not null) - TableScan [TS_12] (rows=1861800 width=89) - default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_244] (rows=280863798 width=39) - Conds:RS_269._col0=RS_261._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9","_col10"] - <-Map 16 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_261] - PartitionCols:_col0 - Select Operator [SEL_260] (rows=652 width=16) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_259] (rows=652 width=106) - predicate:((d_year = 2001) and d_date_sk is not null and d_week_seq is not null and UDFToDouble(d_date) is not null) - TableScan [TS_9] (rows=73049 width=106) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_week_seq","d_year"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_269] - PartitionCols:_col0 - Select Operator [SEL_268] (rows=280863798 width=31) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_267] (rows=280863798 width=31) - predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_ship_date_sk is not null and cs_quantity is not null and cs_bill_hdemo_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_28_d1_d_date_sk_min) AND DynamicValue(RS_28_d1_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_28_d1_d_date_sk_bloom_filter))) - TableScan [TS_6] (rows=287989836 width=31) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_bill_cdemo_sk","cs_bill_hdemo_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_quantity"] - <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_266] - Group By Operator [GBY_265] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 16 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_264] - Group By Operator [GBY_263] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_262] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_260] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_53] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_243] (rows=35703276 width=111) - Conds:RS_255._col2=RS_258._col0(Inner),Output:["_col0","_col1","_col3","_col5"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_255] - PartitionCols:_col2 - Select Operator [SEL_254] (rows=35703276 width=15) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_253] (rows=35703276 width=15) - predicate:(inv_quantity_on_hand is not null and inv_item_sk is not null and inv_warehouse_sk is not null and inv_date_sk is not null) - TableScan [TS_0] (rows=37584000 width=15) - default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_258] - PartitionCols:_col0 - Select Operator [SEL_257] (rows=27 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_256] (rows=27 width=104) - predicate:w_warehouse_sk is not null - TableScan [TS_3] (rows=27 width=104) - default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] + SHUFFLE [RS_294] + Top N Key Operator [TNK_293] (rows=690341337 width=312) + keys:_col5, _col0, _col1, _col2,top n:100 + Group By Operator [GBY_292] (rows=690341337 width=312) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(VALUE._col0)","count(VALUE._col1)","count(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_70] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_69] (rows=2958149194 width=312) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["count(_col3)","count(_col4)","count()"],keys:_col0, _col1, _col2 + Select Operator [SEL_67] (rows=7629034847 width=292) + Output:["_col0","_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_253] (rows=7629034847 width=292) + Conds:RS_64._col4, _col6=RS_291._col0, _col1(Left Outer),Output:["_col13","_col15","_col19","_col25"] + <-Map 24 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_291] + PartitionCols:_col0, _col1 + Select Operator [SEL_290] (rows=28798881 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_289] (rows=28798881 width=8) + predicate:(cr_item_sk is not null and cr_order_number is not null) + TableScan [TS_61] (rows=28798881 width=8) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_64] + PartitionCols:_col4, _col6 + Select Operator [SEL_60] (rows=2958149194 width=300) + Output:["_col4","_col6","_col13","_col15","_col19","_col25"] + Merge Join Operator [MERGEJOIN_252] (rows=2958149194 width=300) + Conds:RS_57._col0, _col19=RS_288._col0, _col1(Inner),Output:["_col5","_col9","_col14","_col16","_col19","_col23"] + <-Map 23 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_288] + PartitionCols:_col0, _col1 + Select Operator [SEL_287] (rows=73049 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_286] (rows=73049 width=8) + predicate:(d_date_sk is not null and d_week_seq is not null) + TableScan [TS_47] (rows=73049 width=8) + default@date_dim,d2,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_week_seq"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_57] + PartitionCols:_col0, _col19 + Filter Operator [FIL_56] (rows=2645646117 width=311) + predicate:(_col3 < _col17) + Merge Join Operator [MERGEJOIN_251] (rows=7936938353 width=311) + Conds:RS_53._col1=RS_54._col8(Inner),Output:["_col0","_col3","_col5","_col9","_col14","_col16","_col17","_col19","_col23"] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_54] + PartitionCols:_col8 + Select Operator [SEL_46] (rows=13907708 width=219) + Output:["_col3","_col8","_col10","_col11","_col13","_col17"] + Filter Operator [FIL_45] (rows=13907708 width=219) + predicate:(_col17 > _col10) + Merge Join Operator [MERGEJOIN_250] (rows=41723124 width=219) + Conds:RS_42._col1=RS_285._col0(Inner),Output:["_col4","_col6","_col7","_col9","_col10","_col13","_col15","_col17"] + <-Map 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_285] + PartitionCols:_col0 + Select Operator [SEL_284] (rows=73049 width=12) + Output:["_col0","_col1"] + Filter Operator [FIL_283] (rows=73049 width=98) + predicate:(d_date_sk is not null and UDFToDouble(d_date) is not null) + TableScan [TS_24] (rows=73049 width=98) + default@date_dim,d3,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_42] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_249] (rows=41723124 width=215) + Conds:RS_39._col4=RS_282._col0(Inner),Output:["_col1","_col4","_col6","_col7","_col9","_col10","_col13","_col15"] + <-Map 21 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_282] + PartitionCols:_col0 + Select Operator [SEL_281] (rows=462000 width=188) + Output:["_col0","_col1"] + Filter Operator [FIL_280] (rows=462000 width=188) + predicate:i_item_sk is not null + TableScan [TS_21] (rows=462000 width=188) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_desc"] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_39] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_248] (rows=41723124 width=31) + Conds:RS_36._col5=RS_279._col0(Left Outer),Output:["_col1","_col4","_col6","_col7","_col9","_col10","_col13"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_279] + PartitionCols:_col0 + Select Operator [SEL_278] (rows=2300 width=4) + Output:["_col0"] + Filter Operator [FIL_277] (rows=2300 width=4) + predicate:p_promo_sk is not null + TableScan [TS_18] (rows=2300 width=4) + default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_36] + PartitionCols:_col5 + Merge Join Operator [MERGEJOIN_247] (rows=41723124 width=31) + Conds:RS_33._col3=RS_276._col0(Inner),Output:["_col1","_col4","_col5","_col6","_col7","_col9","_col10"] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_276] + PartitionCols:_col0 + Select Operator [SEL_275] (rows=1440 width=4) + Output:["_col0"] + Filter Operator [FIL_274] (rows=1440 width=96) + predicate:((hd_buy_potential = '1001-5000') and hd_demo_sk is not null) + TableScan [TS_15] (rows=7200 width=96) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_buy_potential"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_246] (rows=41723124 width=35) + Conds:RS_30._col2=RS_273._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10"] + <-Map 18 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_273] + PartitionCols:_col0 + Select Operator [SEL_272] (rows=265971 width=4) + Output:["_col0"] + Filter Operator [FIL_271] (rows=265971 width=89) + predicate:((cd_marital_status = 'M') and cd_demo_sk is not null) + TableScan [TS_12] (rows=1861800 width=89) + default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_245] (rows=280863798 width=39) + Conds:RS_270._col0=RS_262._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col9","_col10"] + <-Map 16 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_262] + PartitionCols:_col0 + Select Operator [SEL_261] (rows=652 width=16) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_260] (rows=652 width=106) + predicate:((d_year = 2001) and d_date_sk is not null and d_week_seq is not null and UDFToDouble(d_date) is not null) + TableScan [TS_9] (rows=73049 width=106) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date","d_week_seq","d_year"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_270] + PartitionCols:_col0 + Select Operator [SEL_269] (rows=280863798 width=31) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_268] (rows=280863798 width=31) + predicate:(cs_sold_date_sk is not null and cs_bill_cdemo_sk is not null and cs_ship_date_sk is not null and cs_quantity is not null and cs_bill_hdemo_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_28_d1_d_date_sk_min) AND DynamicValue(RS_28_d1_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_28_d1_d_date_sk_bloom_filter))) + TableScan [TS_6] (rows=287989836 width=31) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_bill_cdemo_sk","cs_bill_hdemo_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_quantity"] + <-Reducer 17 [BROADCAST_EDGE] vectorized + BROADCAST [RS_267] + Group By Operator [GBY_266] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 16 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_265] + Group By Operator [GBY_264] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_263] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_261] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_53] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_244] (rows=35703276 width=111) + Conds:RS_256._col2=RS_259._col0(Inner),Output:["_col0","_col1","_col3","_col5"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_256] + PartitionCols:_col2 + Select Operator [SEL_255] (rows=35703276 width=15) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_254] (rows=35703276 width=15) + predicate:(inv_quantity_on_hand is not null and inv_item_sk is not null and inv_warehouse_sk is not null and inv_date_sk is not null) + TableScan [TS_0] (rows=37584000 width=15) + default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_warehouse_sk","inv_quantity_on_hand"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_259] + PartitionCols:_col0 + Select Operator [SEL_258] (rows=27 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_257] (rows=27 width=104) + predicate:w_warehouse_sk is not null + TableScan [TS_3] (rows=27 width=104) + default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] diff --git ql/src/test/results/clientpositive/perf/tez/query74.q.out ql/src/test/results/clientpositive/perf/tez/query74.q.out index f98b9c8815..1535185827 100644 --- ql/src/test/results/clientpositive/perf/tez/query74.q.out +++ ql/src/test/results/clientpositive/perf/tez/query74.q.out @@ -161,239 +161,241 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_353] - Limit [LIM_352] (rows=100 width=280) + File Output Operator [FS_354] + Limit [LIM_353] (rows=100 width=280) Number of rows:100 - Select Operator [SEL_351] (rows=19066162 width=280) + Select Operator [SEL_352] (rows=19066162 width=280) Output:["_col0","_col1","_col2"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_93] Select Operator [SEL_92] (rows=19066162 width=280) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_91] (rows=19066162 width=732) - predicate:CASE WHEN (_col3 is not null) THEN (CASE WHEN (_col6) THEN (((_col1 / _col5) > (_col10 / _col3))) ELSE (false) END) ELSE (false) END - Merge Join Operator [MERGEJOIN_287] (rows=38132324 width=732) - Conds:RS_88._col2=RS_350._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col9","_col10"] - <-Reducer 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_350] - PartitionCols:_col0 - Group By Operator [GBY_349] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 19 [SIMPLE_EDGE] - SHUFFLE [RS_79] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_78] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_284] (rows=525327388 width=386) - Conds:RS_74._col1=RS_317._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_317] + Top N Key Operator [TNK_158] (rows=19066162 width=732) + keys:_col8, _col7, _col9,top n:100 + Filter Operator [FIL_91] (rows=19066162 width=732) + predicate:CASE WHEN (_col3 is not null) THEN (CASE WHEN (_col6) THEN (((_col1 / _col5) > (_col10 / _col3))) ELSE (false) END) ELSE (false) END + Merge Join Operator [MERGEJOIN_288] (rows=38132324 width=732) + Conds:RS_88._col2=RS_351._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col8","_col9","_col10"] + <-Reducer 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_351] + PartitionCols:_col0 + Group By Operator [GBY_350] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 19 [SIMPLE_EDGE] + SHUFFLE [RS_79] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_78] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_285] (rows=525327388 width=386) + Conds:RS_74._col1=RS_318._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_318] + PartitionCols:_col0 + Select Operator [SEL_317] (rows=80000000 width=284) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_316] (rows=80000000 width=284) + predicate:(c_customer_sk is not null and c_customer_id is not null) + TableScan [TS_68] (rows=80000000 width=284) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name"] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_74] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_284] (rows=525327388 width=110) + Conds:RS_349._col0=RS_295._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_295] + PartitionCols:_col0 + Select Operator [SEL_292] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_289] (rows=652 width=8) + predicate:((d_year = 2002) and (d_year) IN (2001, 2002) and d_date_sk is not null) + TableScan [TS_65] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_349] + PartitionCols:_col0 + Select Operator [SEL_348] (rows=525327388 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_347] (rows=525327388 width=114) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_72_date_dim_d_date_sk_min) AND DynamicValue(RS_72_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_72_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_62] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] + <-Reducer 22 [BROADCAST_EDGE] vectorized + BROADCAST [RS_346] + Group By Operator [GBY_345] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_307] + Group By Operator [GBY_303] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_296] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_292] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_88] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_287] (rows=31888273 width=440) + Conds:RS_85._col2=RS_344._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] + <-Reducer 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_344] + PartitionCols:_col0 + Select Operator [SEL_343] (rows=26666666 width=216) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_342] (rows=26666666 width=212) + predicate:(_col3 > 0) + Select Operator [SEL_341] (rows=80000000 width=212) + Output:["_col0","_col3"] + Group By Operator [GBY_340] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_58] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_57] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_283] (rows=143930993 width=391) + Conds:RS_53._col1=RS_321._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_321] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_317] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_53] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_282] (rows=143930993 width=115) + Conds:RS_339._col0=RS_301._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_301] + PartitionCols:_col0 + Select Operator [SEL_294] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_291] (rows=652 width=8) + predicate:((d_year = 2001) and (d_year) IN (2001, 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_65] + <-Map 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_339] + PartitionCols:_col0 + Select Operator [SEL_338] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_337] (rows=143930993 width=119) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_41] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] + <-Reducer 25 [BROADCAST_EDGE] vectorized + BROADCAST [RS_336] + Group By Operator [GBY_335] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_310] + Group By Operator [GBY_306] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_302] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_294] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_85] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_286] (rows=31888273 width=324) + Conds:RS_324._col0=RS_334._col0(Inner),Output:["_col1","_col2","_col3"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_334] PartitionCols:_col0 - Select Operator [SEL_316] (rows=80000000 width=284) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_315] (rows=80000000 width=284) - predicate:(c_customer_sk is not null and c_customer_id is not null) - TableScan [TS_68] (rows=80000000 width=284) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_first_name","c_last_name"] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_74] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_283] (rows=525327388 width=110) - Conds:RS_348._col0=RS_294._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_294] - PartitionCols:_col0 - Select Operator [SEL_291] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_288] (rows=652 width=8) - predicate:((d_year = 2002) and (d_year) IN (2001, 2002) and d_date_sk is not null) - TableScan [TS_65] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_348] - PartitionCols:_col0 - Select Operator [SEL_347] (rows=525327388 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_346] (rows=525327388 width=114) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_72_date_dim_d_date_sk_min) AND DynamicValue(RS_72_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_72_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_62] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] - <-Reducer 22 [BROADCAST_EDGE] vectorized - BROADCAST [RS_345] - Group By Operator [GBY_344] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_306] - Group By Operator [GBY_302] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_295] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_291] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_88] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_286] (rows=31888273 width=440) - Conds:RS_85._col2=RS_343._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6"] - <-Reducer 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_343] - PartitionCols:_col0 - Select Operator [SEL_342] (rows=26666666 width=216) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_341] (rows=26666666 width=212) - predicate:(_col3 > 0) - Select Operator [SEL_340] (rows=80000000 width=212) - Output:["_col0","_col3"] - Group By Operator [GBY_339] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_58] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_57] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_282] (rows=143930993 width=391) - Conds:RS_53._col1=RS_320._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_320] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_316] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_53] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_281] (rows=143930993 width=115) - Conds:RS_338._col0=RS_300._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_300] - PartitionCols:_col0 - Select Operator [SEL_293] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_290] (rows=652 width=8) - predicate:((d_year = 2001) and (d_year) IN (2001, 2002) and d_date_sk is not null) - Please refer to the previous TableScan [TS_65] - <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_338] - PartitionCols:_col0 - Select Operator [SEL_337] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_336] (rows=143930993 width=119) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_41] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] - <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_335] - Group By Operator [GBY_334] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_309] - Group By Operator [GBY_305] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_301] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_293] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_85] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_285] (rows=31888273 width=324) - Conds:RS_323._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_333] - PartitionCols:_col0 - Select Operator [SEL_332] (rows=26666666 width=212) - Output:["_col0","_col1"] - Filter Operator [FIL_331] (rows=26666666 width=212) - predicate:(_col3 > 0) - Select Operator [SEL_330] (rows=80000000 width=212) - Output:["_col0","_col3"] - Group By Operator [GBY_329] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_36] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=386) - Conds:RS_32._col1=RS_319._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_319] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_316] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_279] (rows=525327388 width=110) - Conds:RS_328._col0=RS_298._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_298] - PartitionCols:_col0 - Select Operator [SEL_292] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_289] (rows=652 width=8) - predicate:((d_year = 2001) and (d_year) IN (2001, 2002) and d_date_sk is not null) - Please refer to the previous TableScan [TS_65] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_328] - PartitionCols:_col0 - Select Operator [SEL_327] (rows=525327388 width=114) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_326] (rows=525327388 width=114) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_20] (rows=575995635 width=114) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] - <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_325] - Group By Operator [GBY_324] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_308] - Group By Operator [GBY_304] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_299] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_292] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_323] - PartitionCols:_col0 - Select Operator [SEL_322] (rows=80000000 width=212) - Output:["_col0","_col1"] - Group By Operator [GBY_321] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_17] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_16] (rows=80000000 width=392) - Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 - Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=391) - Conds:RS_12._col1=RS_318._col0(Inner),Output:["_col2","_col5","_col6","_col7"] - <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_318] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_316] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_277] (rows=143930993 width=115) - Conds:RS_314._col0=RS_296._col0(Inner),Output:["_col1","_col2"] - <-Map 21 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_296] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_291] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_314] - PartitionCols:_col0 - Select Operator [SEL_313] (rows=143930993 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_312] (rows=143930993 width=119) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] - <-Reducer 23 [BROADCAST_EDGE] vectorized - BROADCAST [RS_311] - Group By Operator [GBY_310] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_307] - Group By Operator [GBY_303] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_297] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_291] + Select Operator [SEL_333] (rows=26666666 width=212) + Output:["_col0","_col1"] + Filter Operator [FIL_332] (rows=26666666 width=212) + predicate:(_col3 > 0) + Select Operator [SEL_331] (rows=80000000 width=212) + Output:["_col0","_col3"] + Group By Operator [GBY_330] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_36] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_281] (rows=525327388 width=386) + Conds:RS_32._col1=RS_320._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_320] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_317] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_280] (rows=525327388 width=110) + Conds:RS_329._col0=RS_299._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_299] + PartitionCols:_col0 + Select Operator [SEL_293] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_290] (rows=652 width=8) + predicate:((d_year = 2001) and (d_year) IN (2001, 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_65] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_329] + PartitionCols:_col0 + Select Operator [SEL_328] (rows=525327388 width=114) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_327] (rows=525327388 width=114) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_30_date_dim_d_date_sk_min) AND DynamicValue(RS_30_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_30_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_20] (rows=575995635 width=114) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_net_paid"] + <-Reducer 24 [BROADCAST_EDGE] vectorized + BROADCAST [RS_326] + Group By Operator [GBY_325] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_309] + Group By Operator [GBY_305] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_300] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_293] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_324] + PartitionCols:_col0 + Select Operator [SEL_323] (rows=80000000 width=212) + Output:["_col0","_col1"] + Group By Operator [GBY_322] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_17] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_16] (rows=80000000 width=392) + Output:["_col0","_col1","_col2","_col3"],aggregations:["max(_col2)"],keys:_col5, _col6, _col7 + Merge Join Operator [MERGEJOIN_279] (rows=143930993 width=391) + Conds:RS_12._col1=RS_319._col0(Inner),Output:["_col2","_col5","_col6","_col7"] + <-Map 26 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_319] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_317] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_278] (rows=143930993 width=115) + Conds:RS_315._col0=RS_297._col0(Inner),Output:["_col1","_col2"] + <-Map 21 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_297] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_292] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_315] + PartitionCols:_col0 + Select Operator [SEL_314] (rows=143930993 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_313] (rows=143930993 width=119) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_bill_customer_sk","ws_net_paid"] + <-Reducer 23 [BROADCAST_EDGE] vectorized + BROADCAST [RS_312] + Group By Operator [GBY_311] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 21 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_308] + Group By Operator [GBY_304] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_298] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_292] diff --git ql/src/test/results/clientpositive/perf/tez/query75.q.out ql/src/test/results/clientpositive/perf/tez/query75.q.out index b426bf2d1a..960c3b071f 100644 --- ql/src/test/results/clientpositive/perf/tez/query75.q.out +++ ql/src/test/results/clientpositive/perf/tez/query75.q.out @@ -199,394 +199,396 @@ Stage-0 limit:-1 Stage-1 Reducer 10 vectorized - File Output Operator [FS_618] - Select Operator [SEL_617] (rows=100 width=160) + File Output Operator [FS_619] + Select Operator [SEL_618] (rows=100 width=160) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] - Limit [LIM_616] (rows=100 width=152) + Limit [LIM_617] (rows=100 width=152) Number of rows:100 - Select Operator [SEL_615] (rows=7853634 width=152) + Select Operator [SEL_616] (rows=7853634 width=152) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_175] Select Operator [SEL_174] (rows=7853634 width=152) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_173] (rows=7853634 width=256) - predicate:((CAST( _col10 AS decimal(17,2)) / CAST( _col4 AS decimal(17,2))) < 0.9) - Merge Join Operator [MERGEJOIN_518] (rows=23560904 width=256) - Conds:RS_611._col0, _col1, _col2, _col3=RS_614._col0, _col1, _col2, _col3(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col10","_col11"] - <-Reducer 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_614] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_613] (rows=40320 width=136) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 - Group By Operator [GBY_612] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 26 [SIMPLE_EDGE] - <-Reducer 25 [CONTAINS] vectorized - Reduce Output Operator [RS_644] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_643] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_642] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 24 [SIMPLE_EDGE] - <-Reducer 23 [CONTAINS] - Reduce Output Operator [RS_542] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_541] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_539] (rows=455263131 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_538] (rows=455263131 width=177) - Conds:RS_103._col1, _col2=RS_605._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_605] - PartitionCols:_col0, _col1 - Select Operator [SEL_603] (rows=28798881 width=121) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_602] (rows=28798881 width=121) - predicate:(cr_order_number is not null and cr_item_sk is not null) - TableScan [TS_9] (rows=28798881 width=121) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_quantity","cr_return_amount"] - <-Reducer 22 [SIMPLE_EDGE] - SHUFFLE [RS_103] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_510] (rows=273092954 width=139) - Conds:RS_100._col1=RS_599._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_599] - PartitionCols:_col0 - Select Operator [SEL_595] (rows=45745 width=19) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_594] (rows=45745 width=109) - predicate:((i_category = 'Sports') and i_manufact_id is not null and i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) - TableScan [TS_6] (rows=462000 width=109) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id","i_category","i_manufact_id"] - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_100] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_509] (rows=286549727 width=123) - Conds:RS_641._col0=RS_571._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_571] - PartitionCols:_col0 - Select Operator [SEL_562] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_558] (rows=652 width=8) - predicate:((d_year = 2002) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 43 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_641] - PartitionCols:_col0 - Select Operator [SEL_640] (rows=286549727 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_639] (rows=286549727 width=127) - predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_98_date_dim_d_date_sk_min) AND DynamicValue(RS_98_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_98_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_85] (rows=287989836 width=127) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] - <-Reducer 28 [BROADCAST_EDGE] vectorized - BROADCAST [RS_638] - Group By Operator [GBY_637] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_586] - Group By Operator [GBY_580] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_572] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_562] - <-Reducer 31 [CONTAINS] - Reduce Output Operator [RS_551] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_550] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_548] (rows=843378354 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_547] (rows=843378354 width=205) - Conds:RS_125._col1, _col2=RS_627._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 40 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_627] - PartitionCols:_col0, _col1 - Select Operator [SEL_625] (rows=57591150 width=119) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_624] (rows=57591150 width=119) - predicate:(sr_ticket_number is not null and sr_item_sk is not null) - TableScan [TS_31] (rows=57591150 width=119) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_quantity","sr_return_amt"] - <-Reducer 30 [SIMPLE_EDGE] - SHUFFLE [RS_125] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_513] (rows=524244194 width=134) - Conds:RS_122._col1=RS_600._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_600] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_595] - <-Reducer 29 [SIMPLE_EDGE] - SHUFFLE [RS_122] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_512] (rows=550076554 width=118) - Conds:RS_649._col0=RS_573._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_573] - PartitionCols:_col0 - Select Operator [SEL_563] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_559] (rows=652 width=8) - predicate:((d_year = 2002) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 44 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_649] - PartitionCols:_col0 - Select Operator [SEL_648] (rows=550076554 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_647] (rows=550076554 width=122) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_120_date_dim_d_date_sk_min) AND DynamicValue(RS_120_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_120_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_107] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] - <-Reducer 32 [BROADCAST_EDGE] vectorized - BROADCAST [RS_646] - Group By Operator [GBY_645] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_587] - Group By Operator [GBY_581] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_574] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_563] - <-Reducer 35 [CONTAINS] - Reduce Output Operator [RS_556] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_555] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_553] (rows=242954637 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_552] (rows=242954637 width=199) - Conds:RS_154._col1, _col2=RS_636._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 42 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_636] - PartitionCols:_col0, _col1 - Select Operator [SEL_634] (rows=14398467 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_633] (rows=14398467 width=118) - predicate:(wr_order_number is not null and wr_item_sk is not null) - TableScan [TS_60] (rows=14398467 width=118) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_quantity","wr_return_amt"] - <-Reducer 34 [SIMPLE_EDGE] - SHUFFLE [RS_154] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_516] (rows=137205980 width=139) - Conds:RS_151._col1=RS_601._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_601] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_595] - <-Reducer 33 [SIMPLE_EDGE] - SHUFFLE [RS_151] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_515] (rows=143966864 width=123) - Conds:RS_654._col0=RS_575._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_575] - PartitionCols:_col0 - Select Operator [SEL_564] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_560] (rows=652 width=8) - predicate:((d_year = 2002) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 45 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_654] - PartitionCols:_col0 - Select Operator [SEL_653] (rows=143966864 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_652] (rows=143966864 width=127) - predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_149_date_dim_d_date_sk_min) AND DynamicValue(RS_149_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_149_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_136] (rows=144002668 width=127) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] - <-Reducer 36 [BROADCAST_EDGE] vectorized - BROADCAST [RS_651] - Group By Operator [GBY_650] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_588] - Group By Operator [GBY_582] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_576] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_564] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_611] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_610] (rows=40320 width=136) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 - Group By Operator [GBY_609] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 7 [SIMPLE_EDGE] - <-Reducer 19 [CONTAINS] - Reduce Output Operator [RS_537] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_536] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_534] (rows=242954637 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_533] (rows=242954637 width=199) - Conds:RS_69._col1, _col2=RS_635._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 42 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_635] - PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_634] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_69] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_507] (rows=137205980 width=139) - Conds:RS_66._col1=RS_598._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_598] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_595] - <-Reducer 17 [SIMPLE_EDGE] - SHUFFLE [RS_66] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_506] (rows=143966864 width=123) - Conds:RS_632._col0=RS_569._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_569] - PartitionCols:_col0 - Select Operator [SEL_561] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_557] (rows=652 width=8) - predicate:((d_year = 2001) and d_date_sk is not null) - Please refer to the previous TableScan [TS_3] - <-Map 41 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_632] - PartitionCols:_col0 - Select Operator [SEL_631] (rows=143966864 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_630] (rows=143966864 width=127) - predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_64_date_dim_d_date_sk_min) AND DynamicValue(RS_64_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_64_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_51] (rows=144002668 width=127) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] - <-Reducer 20 [BROADCAST_EDGE] vectorized - BROADCAST [RS_629] - Group By Operator [GBY_628] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_585] - Group By Operator [GBY_579] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_570] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_561] - <-Reducer 6 [CONTAINS] vectorized - Reduce Output Operator [RS_608] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_607] (rows=1541596122 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_606] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Union 5 [SIMPLE_EDGE] - <-Reducer 15 [CONTAINS] - Reduce Output Operator [RS_532] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_531] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_529] (rows=843378354 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_528] (rows=843378354 width=205) - Conds:RS_40._col1, _col2=RS_626._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 40 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_626] - PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_625] - <-Reducer 14 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_504] (rows=524244194 width=134) - Conds:RS_37._col1=RS_597._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_597] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_595] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_503] (rows=550076554 width=118) - Conds:RS_623._col0=RS_567._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_567] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_561] - <-Map 39 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_623] - PartitionCols:_col0 - Select Operator [SEL_622] (rows=550076554 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_621] (rows=550076554 width=122) - predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_35_date_dim_d_date_sk_min) AND DynamicValue(RS_35_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_35_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_22] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] - <-Reducer 16 [BROADCAST_EDGE] vectorized - BROADCAST [RS_620] - Group By Operator [GBY_619] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_584] - Group By Operator [GBY_578] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_568] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_561] - <-Reducer 4 [CONTAINS] - Reduce Output Operator [RS_523] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_522] (rows=1298641485 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 - Select Operator [SEL_520] (rows=455263131 width=131) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_519] (rows=455263131 width=177) - Conds:RS_18._col1, _col2=RS_604._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] - <-Map 38 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_604] - PartitionCols:_col0, _col1 - Please refer to the previous Select Operator [SEL_603] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col1, _col2 - Merge Join Operator [MERGEJOIN_501] (rows=273092954 width=139) - Conds:RS_15._col1=RS_596._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] - <-Map 37 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_596] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_595] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_500] (rows=286549727 width=123) - Conds:RS_593._col0=RS_565._col0(Inner),Output:["_col1","_col2","_col3","_col4"] - <-Map 11 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_565] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_561] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_593] - PartitionCols:_col0 - Select Operator [SEL_592] (rows=286549727 width=127) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_591] (rows=286549727 width=127) - predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=287989836 width=127) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] - <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_590] - Group By Operator [GBY_589] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_583] - Group By Operator [GBY_577] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_566] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_561] + Top N Key Operator [TNK_264] (rows=7853634 width=256) + keys:(_col10 - _col4),top n:100 + Filter Operator [FIL_173] (rows=7853634 width=256) + predicate:((CAST( _col10 AS decimal(17,2)) / CAST( _col4 AS decimal(17,2))) < 0.9) + Merge Join Operator [MERGEJOIN_519] (rows=23560904 width=256) + Conds:RS_612._col0, _col1, _col2, _col3=RS_615._col0, _col1, _col2, _col3(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col10","_col11"] + <-Reducer 27 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_615] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_614] (rows=40320 width=136) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 + Group By Operator [GBY_613] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 26 [SIMPLE_EDGE] + <-Reducer 25 [CONTAINS] vectorized + Reduce Output Operator [RS_645] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_644] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_643] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 24 [SIMPLE_EDGE] + <-Reducer 23 [CONTAINS] + Reduce Output Operator [RS_543] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_542] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_540] (rows=455263131 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_539] (rows=455263131 width=177) + Conds:RS_103._col1, _col2=RS_606._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_606] + PartitionCols:_col0, _col1 + Select Operator [SEL_604] (rows=28798881 width=121) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_603] (rows=28798881 width=121) + predicate:(cr_order_number is not null and cr_item_sk is not null) + TableScan [TS_9] (rows=28798881 width=121) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_quantity","cr_return_amount"] + <-Reducer 22 [SIMPLE_EDGE] + SHUFFLE [RS_103] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_511] (rows=273092954 width=139) + Conds:RS_100._col1=RS_600._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_600] + PartitionCols:_col0 + Select Operator [SEL_596] (rows=45745 width=19) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_595] (rows=45745 width=109) + predicate:((i_category = 'Sports') and i_manufact_id is not null and i_category_id is not null and i_brand_id is not null and i_class_id is not null and i_item_sk is not null) + TableScan [TS_6] (rows=462000 width=109) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand_id","i_class_id","i_category_id","i_category","i_manufact_id"] + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_100] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_510] (rows=286549727 width=123) + Conds:RS_642._col0=RS_572._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_572] + PartitionCols:_col0 + Select Operator [SEL_563] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_559] (rows=652 width=8) + predicate:((d_year = 2002) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 43 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_642] + PartitionCols:_col0 + Select Operator [SEL_641] (rows=286549727 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_640] (rows=286549727 width=127) + predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_98_date_dim_d_date_sk_min) AND DynamicValue(RS_98_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_98_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_85] (rows=287989836 width=127) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] + <-Reducer 28 [BROADCAST_EDGE] vectorized + BROADCAST [RS_639] + Group By Operator [GBY_638] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_587] + Group By Operator [GBY_581] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_573] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_563] + <-Reducer 31 [CONTAINS] + Reduce Output Operator [RS_552] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_551] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_549] (rows=843378354 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_548] (rows=843378354 width=205) + Conds:RS_125._col1, _col2=RS_628._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 40 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_628] + PartitionCols:_col0, _col1 + Select Operator [SEL_626] (rows=57591150 width=119) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_625] (rows=57591150 width=119) + predicate:(sr_ticket_number is not null and sr_item_sk is not null) + TableScan [TS_31] (rows=57591150 width=119) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_quantity","sr_return_amt"] + <-Reducer 30 [SIMPLE_EDGE] + SHUFFLE [RS_125] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_514] (rows=524244194 width=134) + Conds:RS_122._col1=RS_601._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_601] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_596] + <-Reducer 29 [SIMPLE_EDGE] + SHUFFLE [RS_122] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_513] (rows=550076554 width=118) + Conds:RS_650._col0=RS_574._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_574] + PartitionCols:_col0 + Select Operator [SEL_564] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_560] (rows=652 width=8) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 44 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_650] + PartitionCols:_col0 + Select Operator [SEL_649] (rows=550076554 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_648] (rows=550076554 width=122) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_120_date_dim_d_date_sk_min) AND DynamicValue(RS_120_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_120_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_107] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] + <-Reducer 32 [BROADCAST_EDGE] vectorized + BROADCAST [RS_647] + Group By Operator [GBY_646] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_588] + Group By Operator [GBY_582] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_575] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_564] + <-Reducer 35 [CONTAINS] + Reduce Output Operator [RS_557] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_556] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_554] (rows=242954637 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_553] (rows=242954637 width=199) + Conds:RS_154._col1, _col2=RS_637._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 42 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_637] + PartitionCols:_col0, _col1 + Select Operator [SEL_635] (rows=14398467 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_634] (rows=14398467 width=118) + predicate:(wr_order_number is not null and wr_item_sk is not null) + TableScan [TS_60] (rows=14398467 width=118) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_quantity","wr_return_amt"] + <-Reducer 34 [SIMPLE_EDGE] + SHUFFLE [RS_154] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_517] (rows=137205980 width=139) + Conds:RS_151._col1=RS_602._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_602] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_596] + <-Reducer 33 [SIMPLE_EDGE] + SHUFFLE [RS_151] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_516] (rows=143966864 width=123) + Conds:RS_655._col0=RS_576._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_576] + PartitionCols:_col0 + Select Operator [SEL_565] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_561] (rows=652 width=8) + predicate:((d_year = 2002) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 45 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_655] + PartitionCols:_col0 + Select Operator [SEL_654] (rows=143966864 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_653] (rows=143966864 width=127) + predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_149_date_dim_d_date_sk_min) AND DynamicValue(RS_149_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_149_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_136] (rows=144002668 width=127) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] + <-Reducer 36 [BROADCAST_EDGE] vectorized + BROADCAST [RS_652] + Group By Operator [GBY_651] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_589] + Group By Operator [GBY_583] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_577] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_565] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_612] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_611] (rows=40320 width=136) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col4)","sum(_col5)"],keys:_col0, _col1, _col2, _col3 + Group By Operator [GBY_610] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 7 [SIMPLE_EDGE] + <-Reducer 19 [CONTAINS] + Reduce Output Operator [RS_538] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_537] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_535] (rows=242954637 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_534] (rows=242954637 width=199) + Conds:RS_69._col1, _col2=RS_636._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 42 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_636] + PartitionCols:_col0, _col1 + Please refer to the previous Select Operator [SEL_635] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_69] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_508] (rows=137205980 width=139) + Conds:RS_66._col1=RS_599._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_599] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_596] + <-Reducer 17 [SIMPLE_EDGE] + SHUFFLE [RS_66] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_507] (rows=143966864 width=123) + Conds:RS_633._col0=RS_570._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_570] + PartitionCols:_col0 + Select Operator [SEL_562] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_558] (rows=652 width=8) + predicate:((d_year = 2001) and d_date_sk is not null) + Please refer to the previous TableScan [TS_3] + <-Map 41 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_633] + PartitionCols:_col0 + Select Operator [SEL_632] (rows=143966864 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_631] (rows=143966864 width=127) + predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_64_date_dim_d_date_sk_min) AND DynamicValue(RS_64_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_64_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_51] (rows=144002668 width=127) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_order_number","ws_quantity","ws_ext_sales_price"] + <-Reducer 20 [BROADCAST_EDGE] vectorized + BROADCAST [RS_630] + Group By Operator [GBY_629] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_586] + Group By Operator [GBY_580] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_571] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_562] + <-Reducer 6 [CONTAINS] vectorized + Reduce Output Operator [RS_609] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_608] (rows=1541596122 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_607] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Union 5 [SIMPLE_EDGE] + <-Reducer 15 [CONTAINS] + Reduce Output Operator [RS_533] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_532] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_530] (rows=843378354 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_529] (rows=843378354 width=205) + Conds:RS_40._col1, _col2=RS_627._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 40 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_627] + PartitionCols:_col0, _col1 + Please refer to the previous Select Operator [SEL_626] + <-Reducer 14 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_505] (rows=524244194 width=134) + Conds:RS_37._col1=RS_598._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_598] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_596] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_504] (rows=550076554 width=118) + Conds:RS_624._col0=RS_568._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_568] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_562] + <-Map 39 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_624] + PartitionCols:_col0 + Select Operator [SEL_623] (rows=550076554 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_622] (rows=550076554 width=122) + predicate:(ss_sold_date_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_35_date_dim_d_date_sk_min) AND DynamicValue(RS_35_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_35_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_22] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_ticket_number","ss_quantity","ss_ext_sales_price"] + <-Reducer 16 [BROADCAST_EDGE] vectorized + BROADCAST [RS_621] + Group By Operator [GBY_620] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_585] + Group By Operator [GBY_579] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_569] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_562] + <-Reducer 4 [CONTAINS] + Reduce Output Operator [RS_524] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_523] (rows=1298641485 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],keys:_col0, _col1, _col2, _col3, _col4, _col5 + Select Operator [SEL_521] (rows=455263131 width=131) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Merge Join Operator [MERGEJOIN_520] (rows=455263131 width=177) + Conds:RS_18._col1, _col2=RS_605._col0, _col1(Left Outer),Output:["_col3","_col4","_col7","_col8","_col9","_col10","_col13","_col14"] + <-Map 38 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_605] + PartitionCols:_col0, _col1 + Please refer to the previous Select Operator [SEL_604] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col1, _col2 + Merge Join Operator [MERGEJOIN_502] (rows=273092954 width=139) + Conds:RS_15._col1=RS_597._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col10"] + <-Map 37 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_597] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_596] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_501] (rows=286549727 width=123) + Conds:RS_594._col0=RS_566._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + <-Map 11 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_566] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_562] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_594] + PartitionCols:_col0 + Select Operator [SEL_593] (rows=286549727 width=127) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_592] (rows=286549727 width=127) + predicate:(cs_sold_date_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_13_date_dim_d_date_sk_min) AND DynamicValue(RS_13_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_13_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=287989836 width=127) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_item_sk","cs_order_number","cs_quantity","cs_ext_sales_price"] + <-Reducer 12 [BROADCAST_EDGE] vectorized + BROADCAST [RS_591] + Group By Operator [GBY_590] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_584] + Group By Operator [GBY_578] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_567] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_562] diff --git ql/src/test/results/clientpositive/perf/tez/query76.q.out ql/src/test/results/clientpositive/perf/tez/query76.q.out index c0d60e88cc..deecf746d3 100644 --- ql/src/test/results/clientpositive/perf/tez/query76.q.out +++ ql/src/test/results/clientpositive/perf/tez/query76.q.out @@ -73,132 +73,132 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_183] - Limit [LIM_182] (rows=100 width=408) + File Output Operator [FS_188] + Limit [LIM_187] (rows=100 width=408) Number of rows:100 - Select Operator [SEL_181] (rows=5600 width=408) + Select Operator [SEL_186] (rows=5600 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_180] - Group By Operator [GBY_179] (rows=5600 width=408) + SHUFFLE [RS_185] + Group By Operator [GBY_184] (rows=5600 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4 <-Union 4 [SIMPLE_EDGE] <-Reducer 10 [CONTAINS] - Reduce Output Operator [RS_167] + Reduce Output Operator [RS_172] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_166] (rows=224000 width=408) + Group By Operator [GBY_171] (rows=224000 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Top N Key Operator [TNK_165] (rows=26219002 width=388) + Top N Key Operator [TNK_170] (rows=26219002 width=388) keys:_col0, _col1, _col2, _col3, _col4,top n:100 - Select Operator [SEL_163] (rows=1433911 width=399) + Select Operator [SEL_168] (rows=1433911 width=399) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_162] (rows=1433911 width=209) - Conds:RS_45._col0=RS_195._col0(Inner),Output:["_col2","_col4","_col6","_col7"] + Merge Join Operator [MERGEJOIN_167] (rows=1433911 width=209) + Conds:RS_45._col0=RS_200._col0(Inner),Output:["_col2","_col4","_col6","_col7"] <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_195] + SHUFFLE [RS_200] PartitionCols:_col0 - Select Operator [SEL_194] (rows=73049 width=12) + Select Operator [SEL_199] (rows=73049 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_193] (rows=73049 width=12) + Filter Operator [FIL_198] (rows=73049 width=12) predicate:d_date_sk is not null TableScan [TS_39] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_45] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_148] (rows=1433911 width=205) - Conds:RS_192._col1=RS_172._col0(Inner),Output:["_col0","_col2","_col4"] + Merge Join Operator [MERGEJOIN_153] (rows=1433911 width=205) + Conds:RS_197._col1=RS_177._col0(Inner),Output:["_col0","_col2","_col4"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_172] + SHUFFLE [RS_177] PartitionCols:_col0 - Select Operator [SEL_169] (rows=462000 width=94) + Select Operator [SEL_174] (rows=462000 width=94) Output:["_col0","_col1"] - Filter Operator [FIL_168] (rows=462000 width=94) + Filter Operator [FIL_173] (rows=462000 width=94) predicate:i_item_sk is not null TableScan [TS_0] (rows=462000 width=94) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_category"] <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_192] + SHUFFLE [RS_197] PartitionCols:_col1 - Select Operator [SEL_191] (rows=1433911 width=119) + Select Operator [SEL_196] (rows=1433911 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_190] (rows=1433911 width=123) + Filter Operator [FIL_195] (rows=1433911 width=123) predicate:(cs_warehouse_sk is null and cs_sold_date_sk is not null and cs_item_sk is not null) TableScan [TS_33] (rows=287989836 width=123) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_warehouse_sk","cs_item_sk","cs_ext_sales_price"] <-Reducer 3 [CONTAINS] - Reduce Output Operator [RS_155] + Reduce Output Operator [RS_160] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_154] (rows=224000 width=408) + Group By Operator [GBY_159] (rows=224000 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Top N Key Operator [TNK_153] (rows=26219002 width=388) + Top N Key Operator [TNK_158] (rows=26219002 width=388) keys:_col0, _col1, _col2, _col3, _col4,top n:100 - Select Operator [SEL_151] (rows=24749363 width=387) + Select Operator [SEL_156] (rows=24749363 width=387) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_150] (rows=24749363 width=204) - Conds:RS_12._col2=RS_178._col0(Inner),Output:["_col1","_col4","_col6","_col7"] + Merge Join Operator [MERGEJOIN_155] (rows=24749363 width=204) + Conds:RS_12._col2=RS_183._col0(Inner),Output:["_col1","_col4","_col6","_col7"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_178] + SHUFFLE [RS_183] PartitionCols:_col0 - Select Operator [SEL_177] (rows=73049 width=12) + Select Operator [SEL_182] (rows=73049 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_176] (rows=73049 width=12) + Filter Operator [FIL_181] (rows=73049 width=12) predicate:d_date_sk is not null TableScan [TS_6] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_144] (rows=24749363 width=200) - Conds:RS_170._col0=RS_175._col1(Inner),Output:["_col1","_col2","_col4"] + Merge Join Operator [MERGEJOIN_149] (rows=24749363 width=200) + Conds:RS_175._col0=RS_180._col1(Inner),Output:["_col1","_col2","_col4"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_170] + SHUFFLE [RS_175] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_169] + Please refer to the previous Select Operator [SEL_174] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_175] + SHUFFLE [RS_180] PartitionCols:_col1 - Select Operator [SEL_174] (rows=24749363 width=114) + Select Operator [SEL_179] (rows=24749363 width=114) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_173] (rows=24749363 width=118) + Filter Operator [FIL_178] (rows=24749363 width=118) predicate:(ss_addr_sk is null and ss_sold_date_sk is not null and ss_item_sk is not null) TableScan [TS_3] (rows=575995635 width=118) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_addr_sk","ss_ext_sales_price"] <-Reducer 8 [CONTAINS] - Reduce Output Operator [RS_161] + Reduce Output Operator [RS_166] PartitionCols:_col0, _col1, _col2, _col3, _col4 - Group By Operator [GBY_160] (rows=224000 width=408) + Group By Operator [GBY_165] (rows=224000 width=408) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["count()","sum(_col5)"],keys:_col0, _col1, _col2, _col3, _col4 - Top N Key Operator [TNK_159] (rows=26219002 width=388) + Top N Key Operator [TNK_164] (rows=26219002 width=388) keys:_col0, _col1, _col2, _col3, _col4,top n:100 - Select Operator [SEL_157] (rows=35728 width=394) + Select Operator [SEL_162] (rows=35728 width=394) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Merge Join Operator [MERGEJOIN_156] (rows=35728 width=209) - Conds:RS_28._col0=RS_189._col0(Inner),Output:["_col2","_col4","_col6","_col7"] + Merge Join Operator [MERGEJOIN_161] (rows=35728 width=209) + Conds:RS_28._col0=RS_194._col0(Inner),Output:["_col2","_col4","_col6","_col7"] <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_189] + SHUFFLE [RS_194] PartitionCols:_col0 - Select Operator [SEL_188] (rows=73049 width=12) + Select Operator [SEL_193] (rows=73049 width=12) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_187] (rows=73049 width=12) + Filter Operator [FIL_192] (rows=73049 width=12) predicate:d_date_sk is not null TableScan [TS_22] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Reducer 7 [SIMPLE_EDGE] SHUFFLE [RS_28] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_146] (rows=35728 width=205) - Conds:RS_186._col1=RS_171._col0(Inner),Output:["_col0","_col2","_col4"] + Merge Join Operator [MERGEJOIN_151] (rows=35728 width=205) + Conds:RS_191._col1=RS_176._col0(Inner),Output:["_col0","_col2","_col4"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_171] + SHUFFLE [RS_176] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_169] + Please refer to the previous Select Operator [SEL_174] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_186] + SHUFFLE [RS_191] PartitionCols:_col1 - Select Operator [SEL_185] (rows=35728 width=119) + Select Operator [SEL_190] (rows=35728 width=119) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_184] (rows=35728 width=123) + Filter Operator [FIL_189] (rows=35728 width=123) predicate:(ws_web_page_sk is null and ws_sold_date_sk is not null and ws_item_sk is not null) TableScan [TS_16] (rows=144002668 width=123) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_ext_sales_price"] diff --git ql/src/test/results/clientpositive/perf/tez/query77.q.out ql/src/test/results/clientpositive/perf/tez/query77.q.out index ab2b3dc570..fcfc5a33bc 100644 --- ql/src/test/results/clientpositive/perf/tez/query77.q.out +++ ql/src/test/results/clientpositive/perf/tez/query77.q.out @@ -1,4 +1,4 @@ -Warning: Shuffle Join MERGEJOIN[317][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product +Warning: Shuffle Join MERGEJOIN[319][tables = [$hdt$_0, $hdt$_1]] in Stage 'Reducer 16' is a cross product PREHOOK: query: explain with ss as (select s_store_sk, @@ -267,280 +267,280 @@ Stage-0 limit:100 Stage-1 Reducer 8 vectorized - File Output Operator [FS_367] - Limit [LIM_366] (rows=100 width=439) + File Output Operator [FS_369] + Limit [LIM_368] (rows=100 width=439) Number of rows:100 - Select Operator [SEL_365] (rows=561 width=439) + Select Operator [SEL_367] (rows=561 width=439) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_364] - Select Operator [SEL_363] (rows=561 width=439) + SHUFFLE [RS_366] + Select Operator [SEL_365] (rows=561 width=439) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_362] (rows=561 width=447) + Group By Operator [GBY_364] (rows=561 width=447) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 6 [SIMPLE_EDGE] <-Reducer 16 [CONTAINS] - Reduce Output Operator [RS_322] + Reduce Output Operator [RS_324] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_321] (rows=561 width=447) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_320] (rows=526 width=435) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_318] (rows=10 width=439) + Top N Key Operator [TNK_323] (rows=561 width=447) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_322] (rows=561 width=447) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_320] (rows=10 width=439) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_317] (rows=10 width=452) + Merge Join Operator [MERGEJOIN_319] (rows=10 width=452) Conds:(Inner),Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 15 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_374] - Group By Operator [GBY_373] (rows=10 width=228) + PARTITION_ONLY_SHUFFLE [RS_376] + Group By Operator [GBY_375] (rows=10 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_55] PartitionCols:_col0 Group By Operator [GBY_54] (rows=2550 width=227) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col1 - Merge Join Operator [MERGEJOIN_302] (rows=286549727 width=227) - Conds:RS_372._col0=RS_334._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_304] (rows=286549727 width=227) + Conds:RS_374._col0=RS_336._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_334] + SHUFFLE [RS_336] PartitionCols:_col0 - Select Operator [SEL_330] (rows=8116 width=4) + Select Operator [SEL_332] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_329] (rows=8116 width=98) + Filter Operator [FIL_331] (rows=8116 width=98) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-08-04 00:00:00' AND TIMESTAMP'1998-09-03 00:00:00' and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Map 30 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_372] + SHUFFLE [RS_374] PartitionCols:_col0 - Select Operator [SEL_371] (rows=286549727 width=231) + Select Operator [SEL_373] (rows=286549727 width=231) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_370] (rows=286549727 width=231) + Filter Operator [FIL_372] (rows=286549727 width=231) predicate:(cs_sold_date_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_51_date_dim_d_date_sk_min) AND DynamicValue(RS_51_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_51_date_dim_d_date_sk_bloom_filter))) TableScan [TS_44] (rows=287989836 width=231) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_call_center_sk","cs_ext_sales_price","cs_net_profit"] <-Reducer 17 [BROADCAST_EDGE] vectorized - BROADCAST [RS_369] - Group By Operator [GBY_368] (rows=1 width=12) + BROADCAST [RS_371] + Group By Operator [GBY_370] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_344] - Group By Operator [GBY_341] (rows=1 width=12) + SHUFFLE [RS_346] + Group By Operator [GBY_343] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_335] (rows=8116 width=4) + Select Operator [SEL_337] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Reducer 19 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_379] - Group By Operator [GBY_378] (rows=1 width=224) + PARTITION_ONLY_SHUFFLE [RS_381] + Group By Operator [GBY_380] (rows=1 width=224) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"] <-Reducer 18 [CUSTOM_SIMPLE_EDGE] PARTITION_ONLY_SHUFFLE [RS_69] Group By Operator [GBY_68] (rows=1 width=224) Output:["_col0","_col1"],aggregations:["sum(_col1)","sum(_col2)"] - Merge Join Operator [MERGEJOIN_303] (rows=3199657 width=183) - Conds:RS_377._col0=RS_336._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_305] (rows=3199657 width=183) + Conds:RS_379._col0=RS_338._col0(Inner),Output:["_col1","_col2"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_336] + SHUFFLE [RS_338] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Map 31 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_377] + SHUFFLE [RS_379] PartitionCols:_col0 - Select Operator [SEL_376] (rows=28798881 width=223) + Select Operator [SEL_378] (rows=28798881 width=223) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_375] (rows=28798881 width=223) + Filter Operator [FIL_377] (rows=28798881 width=223) predicate:cr_returned_date_sk is not null TableScan [TS_58] (rows=28798881 width=223) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_return_amount","cr_net_loss"] <-Reducer 23 [CONTAINS] - Reduce Output Operator [RS_328] + Reduce Output Operator [RS_330] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_327] (rows=561 width=447) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_326] (rows=526 width=435) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_324] (rows=392 width=435) + Top N Key Operator [TNK_329] (rows=561 width=447) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_328] (rows=561 width=447) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_326] (rows=392 width=435) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_323] (rows=392 width=335) - Conds:RS_390._col0=RS_395._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_325] (rows=392 width=335) + Conds:RS_392._col0=RS_397._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] <-Reducer 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_390] + SHUFFLE [RS_392] PartitionCols:_col0 - Group By Operator [GBY_389] (rows=205 width=228) + Group By Operator [GBY_391] (rows=205 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 21 [SIMPLE_EDGE] SHUFFLE [RS_94] PartitionCols:_col0 Group By Operator [GBY_93] (rows=26445 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col5 - Merge Join Operator [MERGEJOIN_305] (rows=143931136 width=227) - Conds:RS_89._col1=RS_387._col0(Inner),Output:["_col2","_col3","_col5"] + Merge Join Operator [MERGEJOIN_307] (rows=143931136 width=227) + Conds:RS_89._col1=RS_389._col0(Inner),Output:["_col2","_col3","_col5"] <-Map 33 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_387] + SHUFFLE [RS_389] PartitionCols:_col0 - Select Operator [SEL_386] (rows=4602 width=4) + Select Operator [SEL_388] (rows=4602 width=4) Output:["_col0"] - Filter Operator [FIL_385] (rows=4602 width=4) + Filter Operator [FIL_387] (rows=4602 width=4) predicate:wp_web_page_sk is not null TableScan [TS_83] (rows=4602 width=4) default@web_page,web_page,Tbl:COMPLETE,Col:COMPLETE,Output:["wp_web_page_sk"] <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_89] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_304] (rows=143931136 width=227) - Conds:RS_384._col0=RS_337._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_306] (rows=143931136 width=227) + Conds:RS_386._col0=RS_339._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_337] + SHUFFLE [RS_339] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Map 32 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_384] + SHUFFLE [RS_386] PartitionCols:_col0 - Select Operator [SEL_383] (rows=143931136 width=231) + Select Operator [SEL_385] (rows=143931136 width=231) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_382] (rows=143931136 width=231) + Filter Operator [FIL_384] (rows=143931136 width=231) predicate:(ws_sold_date_sk is not null and ws_web_page_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_87_date_dim_d_date_sk_min) AND DynamicValue(RS_87_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_87_date_dim_d_date_sk_bloom_filter))) TableScan [TS_77] (rows=144002668 width=231) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_web_page_sk","ws_ext_sales_price","ws_net_profit"] <-Reducer 24 [BROADCAST_EDGE] vectorized - BROADCAST [RS_381] - Group By Operator [GBY_380] (rows=1 width=12) + BROADCAST [RS_383] + Group By Operator [GBY_382] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_345] - Group By Operator [GBY_342] (rows=1 width=12) + SHUFFLE [RS_347] + Group By Operator [GBY_344] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_338] (rows=8116 width=4) + Select Operator [SEL_340] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Reducer 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_395] + SHUFFLE [RS_397] PartitionCols:_col0 - Group By Operator [GBY_394] (rows=187 width=228) + Group By Operator [GBY_396] (rows=187 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 26 [SIMPLE_EDGE] SHUFFLE [RS_114] PartitionCols:_col0 Group By Operator [GBY_113] (rows=2244 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col5 - Merge Join Operator [MERGEJOIN_307] (rows=13129719 width=217) - Conds:RS_109._col1=RS_388._col0(Inner),Output:["_col2","_col3","_col5"] + Merge Join Operator [MERGEJOIN_309] (rows=13129719 width=217) + Conds:RS_109._col1=RS_390._col0(Inner),Output:["_col2","_col3","_col5"] <-Map 33 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_388] + SHUFFLE [RS_390] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_386] + Please refer to the previous Select Operator [SEL_388] <-Reducer 25 [SIMPLE_EDGE] SHUFFLE [RS_109] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_306] (rows=13129719 width=217) - Conds:RS_393._col0=RS_339._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_308] (rows=13129719 width=217) + Conds:RS_395._col0=RS_341._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_339] + SHUFFLE [RS_341] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Map 34 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_393] + SHUFFLE [RS_395] PartitionCols:_col0 - Select Operator [SEL_392] (rows=13129719 width=221) + Select Operator [SEL_394] (rows=13129719 width=221) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_391] (rows=13129719 width=221) + Filter Operator [FIL_393] (rows=13129719 width=221) predicate:(wr_web_page_sk is not null and wr_returned_date_sk is not null) TableScan [TS_97] (rows=14398467 width=221) default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_web_page_sk","wr_return_amt","wr_net_loss"] <-Reducer 5 [CONTAINS] - Reduce Output Operator [RS_316] + Reduce Output Operator [RS_318] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_315] (rows=561 width=447) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_314] (rows=526 width=435) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_312] (rows=124 width=437) + Top N Key Operator [TNK_317] (rows=561 width=447) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_316] (rows=561 width=447) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_314] (rows=124 width=437) Output:["_col0","_col1","_col2","_col3","_col4"] - Merge Join Operator [MERGEJOIN_311] (rows=124 width=379) - Conds:RS_356._col0=RS_361._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] + Merge Join Operator [MERGEJOIN_313] (rows=124 width=379) + Conds:RS_358._col0=RS_363._col0(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5"] <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_361] + SHUFFLE [RS_363] PartitionCols:_col0 - Group By Operator [GBY_360] (rows=84 width=228) + Group By Operator [GBY_362] (rows=84 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_37] PartitionCols:_col0 Group By Operator [GBY_36] (rows=3948 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col5 - Merge Join Operator [MERGEJOIN_301] (rows=53634860 width=220) - Conds:RS_32._col1=RS_354._col0(Inner),Output:["_col2","_col3","_col5"] + Merge Join Operator [MERGEJOIN_303] (rows=53634860 width=220) + Conds:RS_32._col1=RS_356._col0(Inner),Output:["_col2","_col3","_col5"] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_354] + SHUFFLE [RS_356] PartitionCols:_col0 - Select Operator [SEL_352] (rows=1704 width=4) + Select Operator [SEL_354] (rows=1704 width=4) Output:["_col0"] - Filter Operator [FIL_351] (rows=1704 width=4) + Filter Operator [FIL_353] (rows=1704 width=4) predicate:s_store_sk is not null TableScan [TS_6] (rows=1704 width=4) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk"] <-Reducer 11 [SIMPLE_EDGE] SHUFFLE [RS_32] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_300] (rows=53634860 width=220) - Conds:RS_359._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_302] (rows=53634860 width=220) + Conds:RS_361._col0=RS_335._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_333] + SHUFFLE [RS_335] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_359] + SHUFFLE [RS_361] PartitionCols:_col0 - Select Operator [SEL_358] (rows=53634860 width=223) + Select Operator [SEL_360] (rows=53634860 width=223) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_357] (rows=53634860 width=223) + Filter Operator [FIL_359] (rows=53634860 width=223) predicate:(sr_store_sk is not null and sr_returned_date_sk is not null) TableScan [TS_20] (rows=57591150 width=223) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_store_sk","sr_return_amt","sr_net_loss"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_356] + SHUFFLE [RS_358] PartitionCols:_col0 - Group By Operator [GBY_355] (rows=83 width=228) + Group By Operator [GBY_357] (rows=83 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_17] PartitionCols:_col0 Group By Operator [GBY_16] (rows=37184 width=228) Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","sum(_col3)"],keys:_col5 - Merge Join Operator [MERGEJOIN_299] (rows=525329897 width=217) - Conds:RS_12._col1=RS_353._col0(Inner),Output:["_col2","_col3","_col5"] + Merge Join Operator [MERGEJOIN_301] (rows=525329897 width=217) + Conds:RS_12._col1=RS_355._col0(Inner),Output:["_col2","_col3","_col5"] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_353] + SHUFFLE [RS_355] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_352] + Please refer to the previous Select Operator [SEL_354] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_12] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_298] (rows=525329897 width=217) - Conds:RS_350._col0=RS_331._col0(Inner),Output:["_col1","_col2","_col3"] + Merge Join Operator [MERGEJOIN_300] (rows=525329897 width=217) + Conds:RS_352._col0=RS_333._col0(Inner),Output:["_col1","_col2","_col3"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_331] + SHUFFLE [RS_333] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_350] + SHUFFLE [RS_352] PartitionCols:_col0 - Select Operator [SEL_349] (rows=525329897 width=221) + Select Operator [SEL_351] (rows=525329897 width=221) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_348] (rows=525329897 width=221) + Filter Operator [FIL_350] (rows=525329897 width=221) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_10_date_dim_d_date_sk_min) AND DynamicValue(RS_10_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_10_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=221) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_ext_sales_price","ss_net_profit"] <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_347] - Group By Operator [GBY_346] (rows=1 width=12) + BROADCAST [RS_349] + Group By Operator [GBY_348] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_343] - Group By Operator [GBY_340] (rows=1 width=12) + SHUFFLE [RS_345] + Group By Operator [GBY_342] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_332] (rows=8116 width=4) + Select Operator [SEL_334] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_330] + Please refer to the previous Select Operator [SEL_332] diff --git ql/src/test/results/clientpositive/perf/tez/query78.q.out ql/src/test/results/clientpositive/perf/tez/query78.q.out index 4d090af463..c8a4bd7d51 100644 --- ql/src/test/results/clientpositive/perf/tez/query78.q.out +++ ql/src/test/results/clientpositive/perf/tez/query78.q.out @@ -155,199 +155,201 @@ Stage-0 limit:100 Stage-1 Reducer 6 vectorized - File Output Operator [FS_276] - Limit [LIM_275] (rows=100 width=484) + File Output Operator [FS_277] + Limit [LIM_276] (rows=100 width=484) Number of rows:100 - Select Operator [SEL_274] (rows=5221812635292 width=483) + Select Operator [SEL_275] (rows=5221812635292 width=483) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_76] Select Operator [SEL_75] (rows=5221812635292 width=719) Output:["_col0","_col1","_col2","_col6","_col7","_col8","_col9","_col10","_col11","_col12"] - Merge Join Operator [MERGEJOIN_223] (rows=5221812635292 width=715) - Conds:RS_72._col1=RS_273._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col11","_col12","_col13","_col14","_col15"] - <-Reducer 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_273] - PartitionCols:_col0 - Select Operator [SEL_272] (rows=285117831 width=247) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_271] (rows=285117831 width=239) - predicate:(_col2 > 0L) - Select Operator [SEL_270] (rows=285117831 width=239) - Output:["_col1","_col2","_col3","_col4"] - Group By Operator [GBY_269] (rows=285117831 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_64] - PartitionCols:_col0, _col1 - Group By Operator [GBY_63] (rows=285117831 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col2, _col3 - Merge Join Operator [MERGEJOIN_221] (rows=285117831 width=235) - Conds:RS_230._col0=RS_60._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_230] - PartitionCols:_col0 - Select Operator [SEL_225] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_224] (rows=652 width=8) - predicate:((d_year = 2000) and d_date_sk is not null) - TableScan [TS_0] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Reducer 21 [SIMPLE_EDGE] - SHUFFLE [RS_60] - PartitionCols:_col0 - Select Operator [SEL_58] (rows=285117831 width=239) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_57] (rows=285117831 width=240) - predicate:_col8 is null - Merge Join Operator [MERGEJOIN_220] (rows=466377701 width=240) - Conds:RS_265._col2, _col3=RS_268._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_265] - PartitionCols:_col2, _col3 - Select Operator [SEL_264] (rows=285117831 width=242) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_263] (rows=285117831 width=242) - predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_59_date_dim_d_date_sk_min) AND DynamicValue(RS_59_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_59_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_48] (rows=287989836 width=242) - default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_order_number","cs_quantity","cs_wholesale_cost","cs_sales_price"] - <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_262] - Group By Operator [GBY_261] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_237] - Group By Operator [GBY_234] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_231] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_225] - <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_268] - PartitionCols:_col0, _col1 - Select Operator [SEL_267] (rows=28798881 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_266] (rows=28798881 width=8) - predicate:(cr_order_number is not null and cr_item_sk is not null) - TableScan [TS_51] (rows=28798881 width=8) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_72] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_222] (rows=25668026995 width=471) - Conds:RS_248._col1, _col0=RS_260._col1, _col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col7","_col8","_col9"] - <-Reducer 3 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_248] - PartitionCols:_col1, _col0 - Select Operator [SEL_247] (rows=319876350 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_246] (rows=319876350 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_19] - PartitionCols:_col0, _col1 - Group By Operator [GBY_18] (rows=319876350 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col3, _col2 - Merge Join Operator [MERGEJOIN_217] (rows=319876350 width=229) - Conds:RS_226._col0=RS_15._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_226] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_225] - <-Reducer 15 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col0 - Select Operator [SEL_13] (rows=319876350 width=233) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_12] (rows=319876350 width=236) - predicate:_col8 is null - Merge Join Operator [MERGEJOIN_216] (rows=857669906 width=236) - Conds:RS_242._col1, _col3=RS_245._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_242] - PartitionCols:_col1, _col3 - Select Operator [SEL_241] (rows=525327388 width=233) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_240] (rows=525327388 width=233) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_14_date_dim_d_date_sk_min) AND DynamicValue(RS_14_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_14_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_3] (rows=575995635 width=233) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_wholesale_cost","ss_sales_price"] - <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_239] - Group By Operator [GBY_238] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_235] - Group By Operator [GBY_232] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_227] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_225] - <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_245] - PartitionCols:_col0, _col1 - Select Operator [SEL_244] (rows=57591150 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_243] (rows=57591150 width=8) - predicate:(sr_ticket_number is not null and sr_item_sk is not null) - TableScan [TS_6] (rows=57591150 width=8) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_260] - PartitionCols:_col1, _col0 - Select Operator [SEL_259] (rows=113538342 width=239) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_258] (rows=113538342 width=239) - predicate:(_col2 > 0L) - Group By Operator [GBY_257] (rows=113538342 width=239) + Top N Key Operator [TNK_117] (rows=5221812635292 width=715) + keys:_col0, _col1, _col2, _col3, _col4, (CASE WHEN (_col7 is not null) THEN (_col7) ELSE (0L) END + _col13), (CASE WHEN (_col8 is not null) THEN (_col8) ELSE (0) END + _col14), (CASE WHEN (_col9 is not null) THEN (_col9) ELSE (0) END + _col15), round((UDFToDouble(_col2) / UDFToDouble(CASE WHEN ((_col7 is not null and _col11 is not null)) THEN ((_col7 + _col11)) ELSE (1L) END)), 2),top n:100 + Merge Join Operator [MERGEJOIN_224] (rows=5221812635292 width=715) + Conds:RS_72._col1=RS_274._col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col7","_col8","_col9","_col11","_col12","_col13","_col14","_col15"] + <-Reducer 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_274] + PartitionCols:_col0 + Select Operator [SEL_273] (rows=285117831 width=247) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_272] (rows=285117831 width=239) + predicate:(_col2 > 0L) + Select Operator [SEL_271] (rows=285117831 width=239) + Output:["_col1","_col2","_col3","_col4"] + Group By Operator [GBY_270] (rows=285117831 width=239) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_41] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_64] PartitionCols:_col0, _col1 - Group By Operator [GBY_40] (rows=113538342 width=239) + Group By Operator [GBY_63] (rows=285117831 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col2, _col3 + Merge Join Operator [MERGEJOIN_222] (rows=285117831 width=235) + Conds:RS_231._col0=RS_60._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_231] + PartitionCols:_col0 + Select Operator [SEL_226] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_225] (rows=652 width=8) + predicate:((d_year = 2000) and d_date_sk is not null) + TableScan [TS_0] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Reducer 21 [SIMPLE_EDGE] + SHUFFLE [RS_60] + PartitionCols:_col0 + Select Operator [SEL_58] (rows=285117831 width=239) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_57] (rows=285117831 width=240) + predicate:_col8 is null + Merge Join Operator [MERGEJOIN_221] (rows=466377701 width=240) + Conds:RS_266._col2, _col3=RS_269._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_266] + PartitionCols:_col2, _col3 + Select Operator [SEL_265] (rows=285117831 width=242) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_264] (rows=285117831 width=242) + predicate:(cs_sold_date_sk is not null and cs_bill_customer_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_59_date_dim_d_date_sk_min) AND DynamicValue(RS_59_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_59_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_48] (rows=287989836 width=242) + default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_bill_customer_sk","cs_item_sk","cs_order_number","cs_quantity","cs_wholesale_cost","cs_sales_price"] + <-Reducer 13 [BROADCAST_EDGE] vectorized + BROADCAST [RS_263] + Group By Operator [GBY_262] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_238] + Group By Operator [GBY_235] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_232] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_226] + <-Map 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_269] + PartitionCols:_col0, _col1 + Select Operator [SEL_268] (rows=28798881 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_267] (rows=28798881 width=8) + predicate:(cr_order_number is not null and cr_item_sk is not null) + TableScan [TS_51] (rows=28798881 width=8) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number"] + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_72] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_223] (rows=25668026995 width=471) + Conds:RS_249._col1, _col0=RS_261._col1, _col0(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col7","_col8","_col9"] + <-Reducer 3 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_249] + PartitionCols:_col1, _col0 + Select Operator [SEL_248] (rows=319876350 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"] + Group By Operator [GBY_247] (rows=319876350 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_19] + PartitionCols:_col0, _col1 + Group By Operator [GBY_18] (rows=319876350 width=239) Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col3, _col2 - Merge Join Operator [MERGEJOIN_219] (rows=113538342 width=235) - Conds:RS_228._col0=RS_37._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] + Merge Join Operator [MERGEJOIN_218] (rows=319876350 width=229) + Conds:RS_227._col0=RS_15._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_228] + SHUFFLE [RS_227] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_225] - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_37] + Please refer to the previous Select Operator [SEL_226] + <-Reducer 15 [SIMPLE_EDGE] + SHUFFLE [RS_15] PartitionCols:_col0 - Select Operator [SEL_35] (rows=113538342 width=239) + Select Operator [SEL_13] (rows=319876350 width=233) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_34] (rows=113538342 width=242) + Filter Operator [FIL_12] (rows=319876350 width=236) predicate:_col8 is null - Merge Join Operator [MERGEJOIN_218] (rows=254644510 width=242) - Conds:RS_253._col1, _col3=RS_256._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_253] + Merge Join Operator [MERGEJOIN_217] (rows=857669906 width=236) + Conds:RS_243._col1, _col3=RS_246._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_243] PartitionCols:_col1, _col3 - Select Operator [SEL_252] (rows=143930993 width=243) + Select Operator [SEL_242] (rows=525327388 width=233) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_251] (rows=143930993 width=243) - predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_36_date_dim_d_date_sk_min) AND DynamicValue(RS_36_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_36_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_25] (rows=144002668 width=243) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_order_number","ws_quantity","ws_wholesale_cost","ws_sales_price"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_250] - Group By Operator [GBY_249] (rows=1 width=12) + Filter Operator [FIL_241] (rows=525327388 width=233) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_14_date_dim_d_date_sk_min) AND DynamicValue(RS_14_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_14_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_3] (rows=575995635 width=233) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_wholesale_cost","ss_sales_price"] + <-Reducer 7 [BROADCAST_EDGE] vectorized + BROADCAST [RS_240] + Group By Operator [GBY_239] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized SHUFFLE [RS_236] Group By Operator [GBY_233] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_229] (rows=652 width=4) + Select Operator [SEL_228] (rows=652 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_225] - <-Map 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_256] + Please refer to the previous Select Operator [SEL_226] + <-Map 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_246] PartitionCols:_col0, _col1 - Select Operator [SEL_255] (rows=14398467 width=8) + Select Operator [SEL_245] (rows=57591150 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_254] (rows=14398467 width=8) - predicate:(wr_order_number is not null and wr_item_sk is not null) - TableScan [TS_28] (rows=14398467 width=8) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number"] + Filter Operator [FIL_244] (rows=57591150 width=8) + predicate:(sr_ticket_number is not null and sr_item_sk is not null) + TableScan [TS_6] (rows=57591150 width=8) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_261] + PartitionCols:_col1, _col0 + Select Operator [SEL_260] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_259] (rows=113538342 width=239) + predicate:(_col2 > 0L) + Group By Operator [GBY_258] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_41] + PartitionCols:_col0, _col1 + Group By Operator [GBY_40] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)"],keys:_col3, _col2 + Merge Join Operator [MERGEJOIN_220] (rows=113538342 width=235) + Conds:RS_229._col0=RS_37._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_229] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_226] + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_37] + PartitionCols:_col0 + Select Operator [SEL_35] (rows=113538342 width=239) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_34] (rows=113538342 width=242) + predicate:_col8 is null + Merge Join Operator [MERGEJOIN_219] (rows=254644510 width=242) + Conds:RS_254._col1, _col3=RS_257._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col4","_col5","_col6","_col8"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_254] + PartitionCols:_col1, _col3 + Select Operator [SEL_253] (rows=143930993 width=243) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + Filter Operator [FIL_252] (rows=143930993 width=243) + predicate:(ws_bill_customer_sk is not null and ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_36_date_dim_d_date_sk_min) AND DynamicValue(RS_36_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_36_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_25] (rows=144002668 width=243) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_bill_customer_sk","ws_order_number","ws_quantity","ws_wholesale_cost","ws_sales_price"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_251] + Group By Operator [GBY_250] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 1 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_237] + Group By Operator [GBY_234] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_230] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_226] + <-Map 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_257] + PartitionCols:_col0, _col1 + Select Operator [SEL_256] (rows=14398467 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_255] (rows=14398467 width=8) + predicate:(wr_order_number is not null and wr_item_sk is not null) + TableScan [TS_28] (rows=14398467 width=8) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number"] diff --git ql/src/test/results/clientpositive/perf/tez/query79.q.out ql/src/test/results/clientpositive/perf/tez/query79.q.out index e1ef37ad38..f7c8e2f937 100644 --- ql/src/test/results/clientpositive/perf/tez/query79.q.out +++ ql/src/test/results/clientpositive/perf/tez/query79.q.out @@ -71,95 +71,97 @@ Stage-0 limit:-1 Stage-1 Reducer 3 vectorized - File Output Operator [FS_126] - Limit [LIM_125] (rows=100 width=776) + File Output Operator [FS_127] + Limit [LIM_126] (rows=100 width=776) Number of rows:100 - Select Operator [SEL_124] (rows=479121995 width=776) + Select Operator [SEL_125] (rows=479121995 width=776) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_33] Select Operator [SEL_32] (rows=479121995 width=776) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Merge Join Operator [MERGEJOIN_100] (rows=479121995 width=685) - Conds:RS_103._col0=RS_123._col1(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_103] - PartitionCols:_col0 - Select Operator [SEL_102] (rows=80000000 width=184) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_101] (rows=80000000 width=184) - predicate:c_customer_sk is not null - TableScan [TS_0] (rows=80000000 width=184) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_first_name","c_last_name"] - <-Reducer 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_123] - PartitionCols:_col1 - Select Operator [SEL_122] (rows=479121995 width=508) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Group By Operator [GBY_121] (rows=479121995 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_26] - PartitionCols:_col0, _col1, _col2, _col3 - Group By Operator [GBY_25] (rows=479121995 width=328) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col3, _col5, _col10 - Merge Join Operator [MERGEJOIN_99] (rows=479121995 width=318) - Conds:RS_21._col2=RS_120._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col10"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_120] - PartitionCols:_col0 - Select Operator [SEL_119] (rows=6415 width=4) - Output:["_col0"] - Filter Operator [FIL_118] (rows=6415 width=12) - predicate:(((hd_dep_count = 8) or (hd_vehicle_count > 0)) and hd_demo_sk is not null) - TableScan [TS_12] (rows=7200 width=12) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] - <-Reducer 6 [SIMPLE_EDGE] - SHUFFLE [RS_21] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_98] (rows=479121995 width=322) - Conds:RS_18._col4=RS_117._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col10"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] - PartitionCols:_col0 - Select Operator [SEL_116] (rows=1704 width=97) - Output:["_col0","_col1"] - Filter Operator [FIL_115] (rows=1704 width=100) - predicate:(s_number_employees BETWEEN 200 AND 295 and s_store_sk is not null) - TableScan [TS_9] (rows=1704 width=100) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_number_employees","s_city"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_97] (rows=479121995 width=233) - Conds:RS_114._col0=RS_106._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_106] - PartitionCols:_col0 - Select Operator [SEL_105] (rows=391 width=4) - Output:["_col0"] - Filter Operator [FIL_104] (rows=391 width=12) - predicate:((d_dow = 1) and (d_year) IN (1998, 1999, 2000) and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] - <-Map 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_114] - PartitionCols:_col0 - Select Operator [SEL_113] (rows=479121995 width=237) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_112] (rows=479121995 width=237) - predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_3] (rows=575995635 width=237) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_111] - Group By Operator [GBY_110] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_109] - Group By Operator [GBY_108] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_107] (rows=391 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_105] + Top N Key Operator [TNK_57] (rows=479121995 width=685) + keys:_col2, _col1, substr(_col5, 1, 30), _col7,top n:100 + Merge Join Operator [MERGEJOIN_101] (rows=479121995 width=685) + Conds:RS_104._col0=RS_124._col1(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col8"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_104] + PartitionCols:_col0 + Select Operator [SEL_103] (rows=80000000 width=184) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_102] (rows=80000000 width=184) + predicate:c_customer_sk is not null + TableScan [TS_0] (rows=80000000 width=184) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_first_name","c_last_name"] + <-Reducer 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_124] + PartitionCols:_col1 + Select Operator [SEL_123] (rows=479121995 width=508) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Group By Operator [GBY_122] (rows=479121995 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3 + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_26] + PartitionCols:_col0, _col1, _col2, _col3 + Group By Operator [GBY_25] (rows=479121995 width=328) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col6)","sum(_col7)"],keys:_col1, _col3, _col5, _col10 + Merge Join Operator [MERGEJOIN_100] (rows=479121995 width=318) + Conds:RS_21._col2=RS_121._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col7","_col10"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_121] + PartitionCols:_col0 + Select Operator [SEL_120] (rows=6415 width=4) + Output:["_col0"] + Filter Operator [FIL_119] (rows=6415 width=12) + predicate:(((hd_dep_count = 8) or (hd_vehicle_count > 0)) and hd_demo_sk is not null) + TableScan [TS_12] (rows=7200 width=12) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_dep_count","hd_vehicle_count"] + <-Reducer 6 [SIMPLE_EDGE] + SHUFFLE [RS_21] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_99] (rows=479121995 width=322) + Conds:RS_18._col4=RS_118._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col7","_col10"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_118] + PartitionCols:_col0 + Select Operator [SEL_117] (rows=1704 width=97) + Output:["_col0","_col1"] + Filter Operator [FIL_116] (rows=1704 width=100) + predicate:(s_number_employees BETWEEN 200 AND 295 and s_store_sk is not null) + TableScan [TS_9] (rows=1704 width=100) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_number_employees","s_city"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_98] (rows=479121995 width=233) + Conds:RS_115._col0=RS_107._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_107] + PartitionCols:_col0 + Select Operator [SEL_106] (rows=391 width=4) + Output:["_col0"] + Filter Operator [FIL_105] (rows=391 width=12) + predicate:((d_dow = 1) and (d_year) IN (1998, 1999, 2000) and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_dow"] + <-Map 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_115] + PartitionCols:_col0 + Select Operator [SEL_114] (rows=479121995 width=237) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_113] (rows=479121995 width=237) + predicate:(ss_sold_date_sk is not null and ss_customer_sk is not null and ss_hdemo_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_3] (rows=575995635 width=237) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_customer_sk","ss_hdemo_sk","ss_addr_sk","ss_store_sk","ss_ticket_number","ss_coupon_amt","ss_net_profit"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_112] + Group By Operator [GBY_111] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_110] + Group By Operator [GBY_109] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_108] (rows=391 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_106] diff --git ql/src/test/results/clientpositive/perf/tez/query8.q.out ql/src/test/results/clientpositive/perf/tez/query8.q.out index 0af8fdf3df..c72498b107 100644 --- ql/src/test/results/clientpositive/perf/tez/query8.q.out +++ ql/src/test/results/clientpositive/perf/tez/query8.q.out @@ -245,141 +245,141 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_149] - Limit [LIM_148] (rows=1 width=200) + File Output Operator [FS_154] + Limit [LIM_153] (rows=1 width=200) Number of rows:100 - Select Operator [SEL_147] (rows=1 width=200) + Select Operator [SEL_152] (rows=1 width=200) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_146] - Group By Operator [GBY_145] (rows=1 width=200) + SHUFFLE [RS_151] + Group By Operator [GBY_150] (rows=1 width=200) Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_57] PartitionCols:_col0 Group By Operator [GBY_56] (rows=401 width=200) Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col6 - Top N Key Operator [TNK_84] (rows=525329897 width=194) + Top N Key Operator [TNK_87] (rows=525329897 width=194) keys:_col6,top n:100 - Merge Join Operator [MERGEJOIN_118] (rows=525329897 width=194) + Merge Join Operator [MERGEJOIN_123] (rows=525329897 width=194) Conds:RS_52._col1=RS_53._col1(Inner),Output:["_col2","_col6"] <-Reducer 12 [SIMPLE_EDGE] SHUFFLE [RS_53] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_117] (rows=1 width=92) - Conds:RS_141._col0=RS_144._col2(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_122] (rows=1 width=92) + Conds:RS_146._col0=RS_149._col2(Inner),Output:["_col1","_col2"] <-Map 18 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_144] + SHUFFLE [RS_149] PartitionCols:_col2 - Select Operator [SEL_143] (rows=1704 width=276) + Select Operator [SEL_148] (rows=1704 width=276) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_142] (rows=1704 width=181) + Filter Operator [FIL_147] (rows=1704 width=181) predicate:(s_store_sk is not null and substr(s_zip, 1, 2) is not null) TableScan [TS_42] (rows=1704 width=181) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_zip"] <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_141] + SHUFFLE [RS_146] PartitionCols:_col0 - Select Operator [SEL_140] (rows=1 width=184) + Select Operator [SEL_145] (rows=1 width=184) Output:["_col0"] - Filter Operator [FIL_139] (rows=1 width=192) + Filter Operator [FIL_144] (rows=1 width=192) predicate:(_col1 = 2L) - Group By Operator [GBY_138] (rows=5633 width=192) + Group By Operator [GBY_143] (rows=5633 width=192) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Union 10 [SIMPLE_EDGE] <-Reducer 16 [CONTAINS] vectorized - Reduce Output Operator [RS_170] + Reduce Output Operator [RS_175] PartitionCols:_col0 - Group By Operator [GBY_169] (rows=5633 width=192) + Group By Operator [GBY_174] (rows=5633 width=192) Output:["_col0","_col1"],aggregations:["count(_col1)"],keys:_col0 - Group By Operator [GBY_168] (rows=1126 width=192) + Group By Operator [GBY_173] (rows=1126 width=192) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Reducer 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_167] + SHUFFLE [RS_172] PartitionCols:_col0 - Group By Operator [GBY_166] (rows=1126 width=192) + Group By Operator [GBY_171] (rows=1126 width=192) Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 - Select Operator [SEL_165] (rows=2253 width=97) + Select Operator [SEL_170] (rows=2253 width=97) Output:["_col0"] - Filter Operator [FIL_164] (rows=2253 width=97) + Filter Operator [FIL_169] (rows=2253 width=97) predicate:(_col1 > 10L) - Group By Operator [GBY_163] (rows=6761 width=97) + Group By Operator [GBY_168] (rows=6761 width=97) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_25] PartitionCols:_col0 Group By Operator [GBY_24] (rows=67610 width=97) Output:["_col0","_col1"],aggregations:["count()"],keys:_col1 - Merge Join Operator [MERGEJOIN_116] (rows=26666667 width=89) - Conds:RS_159._col0=RS_162._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_121] (rows=26666667 width=89) + Conds:RS_164._col0=RS_167._col0(Inner),Output:["_col1"] <-Map 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_159] + SHUFFLE [RS_164] PartitionCols:_col0 - Select Operator [SEL_158] (rows=40000000 width=93) + Select Operator [SEL_163] (rows=40000000 width=93) Output:["_col0","_col1"] - Filter Operator [FIL_157] (rows=40000000 width=93) + Filter Operator [FIL_162] (rows=40000000 width=93) predicate:(ca_address_sk is not null and substr(substr(ca_zip, 1, 5), 1, 2) is not null) TableScan [TS_14] (rows=40000000 width=93) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_zip"] <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_162] + SHUFFLE [RS_167] PartitionCols:_col0 - Select Operator [SEL_161] (rows=26666667 width=4) + Select Operator [SEL_166] (rows=26666667 width=4) Output:["_col0"] - Filter Operator [FIL_160] (rows=26666667 width=89) + Filter Operator [FIL_165] (rows=26666667 width=89) predicate:((c_preferred_cust_flag = 'Y') and c_current_addr_sk is not null) TableScan [TS_17] (rows=80000000 width=89) default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_current_addr_sk","c_preferred_cust_flag"] <-Reducer 9 [CONTAINS] vectorized - Reduce Output Operator [RS_156] + Reduce Output Operator [RS_161] PartitionCols:_col0 - Group By Operator [GBY_155] (rows=5633 width=192) + Group By Operator [GBY_160] (rows=5633 width=192) Output:["_col0","_col1"],aggregations:["count(_col1)"],keys:_col0 - Group By Operator [GBY_154] (rows=10141 width=192) + Group By Operator [GBY_159] (rows=10141 width=192) Output:["_col0","_col1"],aggregations:["count(VALUE._col0)"],keys:KEY._col0 <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_153] + SHUFFLE [RS_158] PartitionCols:_col0 - Group By Operator [GBY_152] (rows=141974 width=192) + Group By Operator [GBY_157] (rows=141974 width=192) Output:["_col0","_col1"],aggregations:["count()"],keys:_col0 - Select Operator [SEL_151] (rows=20000000 width=89) + Select Operator [SEL_156] (rows=20000000 width=89) Output:["_col0"] - Filter Operator [FIL_150] (rows=20000000 width=89) + Filter Operator [FIL_155] (rows=20000000 width=89) predicate:((substr(ca_zip, 1, 5)) IN ('89436', '30868', '65085', '22977', '83927', '77557', '58429', '40697', '80614', '10502', '32779', '91137', '61265', '98294', '17921', '18427', '21203', '59362', '87291', '84093', '21505', '17184', '10866', '67898', '25797', '28055', '18377', '80332', '74535', '21757', '29742', '90885', '29898', '17819', '40811', '25990', '47513', '89531', '91068', '10391', '18846', '99223', '82637', '41368', '83658', '86199', '81625', '26696', '89338', '88425', '32200', '81427', '19053', '77471', '36610', '99823', '43276', '41249', '48584', '83550', '82276', '18842', '78890', '14090', '38123', '40936', '34425', '19850', '43286', '80072', '79188', '54191', '11395', '50497', '84861', '90733', '21068', '57666', '37119', '25004', '57835', '70067', '62878', '95806', '19303', '18840', '19124', '29785', '16737', '16022', '49613', '89977', '68310', '60069', '98360', '48649', '39050', '41793', '25002', '27413', '39736', '47208', '16515', '94808', '57648', '15009', '80015', '42961', '63982', '21744', '71853', '81087', '67468', '34175', '64008', '20261', '11201', '51799', '48043', '45645', '61163', '48375', '36447', '57042', '21218', '41100', '89951', '22745', '35851', '83326', '61125', '78298', '80752', '49858', '52940', '96976', '63792', '11376', '53582', '18717', '90226', '50530', '94203', '99447', '27670', '96577', '57856', '56372', '16165', '23427', '54561', '28806', '44439', '22926', '30123', '61451', '92397', '56979', '92309', '70873', '13355', '21801', '46346', '37562', '56458', '28286', '47306', '99555', '69399', '26234', '47546', '49661', '88601', '35943', '39936', '25632', '24611', '44166', '56648', '30379', '59785', '11110', '14329', '93815', '52226', '71381', '13842', '25612', '63294', '14664', '21077', '82626', '18799', '60915', '81020', '56447', '76619', '11433', '13414', '42548', '92713', '70467', '30884', '47484', '16072', '38936', '13036', '88376', '45539', '35901', '19506', '65690', '73957', '71850', '49231', '14276', '20005', '18384', '76615', '11635', '38177', '55607', '41369', '95447', '58581', '58149', '91946', '33790', '76232', '75692', '95464', '22246', '51061', '56692', '53121', '77209', '15482', '10688', '14868', '45907', '73520', '72666', '25734', '17959', '24677', '66446', '94627', '53535', '15560', '41967', '69297', '11929', '59403', '33283', '52232', '57350', '43933', '40921', '36635', '10827', '71286', '19736', '80619', '25251', '95042', '15526', '36496', '55854', '49124', '81980', '35375', '49157', '63512', '28944', '14946', '36503', '54010', '18767', '23969', '43905', '66979', '33113', '21286', '58471', '59080', '13395', '79144', '70373', '67031', '38360', '26705', '50906', '52406', '26066', '73146', '15884', '31897', '30045', '61068', '45550', '92454', '13376', '14354', '19770', '22928', '97790', '50723', '46081', '30202', '14410', '20223', '88500', '67298', '13261', '14172', '81410', '93578', '83583', '46047', '94167', '82564', '21156', '15799', '86709', '37931', '74703', '83103', '23054', '70470', '72008', '49247', '91911', '69998', '20961', '70070', '63197', '54853', '88191', '91830', '49521', '19454', '81450', '89091', '62378', '25683', '61869', '51744', '36580', '85778', '36871', '48121', '28810', '83712', '45486', '67393', '26935', '42393', '20132', '55349', '86057', '21309', '80218', '10094', '11357', '48819', '39734', '40758', '30432', '21204', '29467', '30214', '61024', '55307', '74621', '11622', '68908', '33032', '52868', '99194', '99900', '84936', '69036', '99149', '45013', '32895', '59004', '32322', '14933', '32936', '33562', '72550', '27385', '58049', '58200', '16808', '21360', '32961', '18586', '79307', '15492') and substr(substr(ca_zip, 1, 5), 1, 2) is not null) TableScan [TS_6] (rows=40000000 width=89) default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_zip"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_52] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_115] (rows=525329897 width=110) - Conds:RS_137._col0=RS_129._col0(Inner),Output:["_col1","_col2"] + Merge Join Operator [MERGEJOIN_120] (rows=525329897 width=110) + Conds:RS_142._col0=RS_134._col0(Inner),Output:["_col1","_col2"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_129] + PARTITION_ONLY_SHUFFLE [RS_134] PartitionCols:_col0 - Select Operator [SEL_128] (rows=130 width=4) + Select Operator [SEL_133] (rows=130 width=4) Output:["_col0"] - Filter Operator [FIL_127] (rows=130 width=12) + Filter Operator [FIL_132] (rows=130 width=12) predicate:((d_year = 2002) and (d_qoy = 1) and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=12) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_qoy"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_137] + SHUFFLE [RS_142] PartitionCols:_col0 - Select Operator [SEL_136] (rows=525329897 width=114) + Select Operator [SEL_141] (rows=525329897 width=114) Output:["_col0","_col1","_col2"] - Filter Operator [FIL_135] (rows=525329897 width=114) + Filter Operator [FIL_140] (rows=525329897 width=114) predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_50_date_dim_d_date_sk_min) AND DynamicValue(RS_50_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_50_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=114) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_store_sk","ss_net_profit"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_134] - Group By Operator [GBY_133] (rows=1 width=12) + BROADCAST [RS_139] + Group By Operator [GBY_138] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_132] - Group By Operator [GBY_131] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_137] + Group By Operator [GBY_136] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_130] (rows=130 width=4) + Select Operator [SEL_135] (rows=130 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_128] + Please refer to the previous Select Operator [SEL_133] diff --git ql/src/test/results/clientpositive/perf/tez/query80.q.out ql/src/test/results/clientpositive/perf/tez/query80.q.out index 47844158fa..3020b58781 100644 --- ql/src/test/results/clientpositive/perf/tez/query80.q.out +++ ql/src/test/results/clientpositive/perf/tez/query80.q.out @@ -249,28 +249,28 @@ Stage-0 limit:100 Stage-1 Reducer 10 vectorized - File Output Operator [FS_438] - Limit [LIM_437] (rows=100 width=619) + File Output Operator [FS_440] + Limit [LIM_439] (rows=100 width=619) Number of rows:100 - Select Operator [SEL_436] (rows=59581 width=619) + Select Operator [SEL_438] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_435] - Select Operator [SEL_434] (rows=59581 width=619) + SHUFFLE [RS_437] + Select Operator [SEL_436] (rows=59581 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_433] (rows=59581 width=627) + Group By Operator [GBY_435] (rows=59581 width=627) Output:["_col0","_col1","_col3","_col4","_col5"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Union 8 [SIMPLE_EDGE] <-Reducer 18 [CONTAINS] vectorized - Reduce Output Operator [RS_454] + Reduce Output Operator [RS_456] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_453] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_452] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_451] (rows=38846 width=619) + Top N Key Operator [TNK_455] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_454] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_453] (rows=38846 width=619) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_450] (rows=38846 width=436) + Group By Operator [GBY_452] (rows=38846 width=436) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 17 [SIMPLE_EDGE] SHUFFLE [RS_75] @@ -279,103 +279,103 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_72] (rows=154681759 width=322) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_369] (rows=154681759 width=322) - Conds:RS_69._col1=RS_449._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] + Merge Join Operator [MERGEJOIN_371] (rows=154681759 width=322) + Conds:RS_69._col1=RS_451._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] <-Map 32 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_449] + SHUFFLE [RS_451] PartitionCols:_col0 - Select Operator [SEL_448] (rows=46000 width=104) + Select Operator [SEL_450] (rows=46000 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_447] (rows=46000 width=104) + Filter Operator [FIL_449] (rows=46000 width=104) predicate:cp_catalog_page_sk is not null TableScan [TS_54] (rows=46000 width=104) default@catalog_page,catalog_page,Tbl:COMPLETE,Col:COMPLETE,Output:["cp_catalog_page_sk","cp_catalog_page_id"] <-Reducer 16 [SIMPLE_EDGE] SHUFFLE [RS_69] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_368] (rows=154681759 width=226) - Conds:RS_66._col3=RS_423._col0(Inner),Output:["_col1","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_370] (rows=154681759 width=226) + Conds:RS_66._col3=RS_425._col0(Inner),Output:["_col1","_col5","_col6","_col9","_col10"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_423] + SHUFFLE [RS_425] PartitionCols:_col0 - Select Operator [SEL_421] (rows=1150 width=4) + Select Operator [SEL_423] (rows=1150 width=4) Output:["_col0"] - Filter Operator [FIL_420] (rows=1150 width=89) + Filter Operator [FIL_422] (rows=1150 width=89) predicate:((p_channel_tv = 'N') and p_promo_sk is not null) TableScan [TS_12] (rows=2300 width=89) default@promotion,promotion,Tbl:COMPLETE,Col:COMPLETE,Output:["p_promo_sk","p_channel_tv"] <-Reducer 15 [SIMPLE_EDGE] SHUFFLE [RS_66] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_367] (rows=154681759 width=230) - Conds:RS_63._col2=RS_418._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_369] (rows=154681759 width=230) + Conds:RS_63._col2=RS_420._col0(Inner),Output:["_col1","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_418] + SHUFFLE [RS_420] PartitionCols:_col0 - Select Operator [SEL_416] (rows=154000 width=4) + Select Operator [SEL_418] (rows=154000 width=4) Output:["_col0"] - Filter Operator [FIL_415] (rows=154000 width=115) + Filter Operator [FIL_417] (rows=154000 width=115) predicate:((i_current_price > 50) and i_item_sk is not null) TableScan [TS_9] (rows=462000 width=115) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_current_price"] <-Reducer 14 [SIMPLE_EDGE] SHUFFLE [RS_63] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_366] (rows=464045263 width=322) - Conds:RS_60._col0=RS_397._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_368] (rows=464045263 width=322) + Conds:RS_60._col0=RS_399._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_397] + SHUFFLE [RS_399] PartitionCols:_col0 - Select Operator [SEL_394] (rows=8116 width=4) + Select Operator [SEL_396] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_393] (rows=8116 width=98) + Filter Operator [FIL_395] (rows=8116 width=98) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'1998-08-04 00:00:00' AND TIMESTAMP'1998-09-03 00:00:00' and d_date_sk is not null) TableScan [TS_6] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Reducer 30 [SIMPLE_EDGE] SHUFFLE [RS_60] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_365] (rows=464045263 width=326) - Conds:RS_443._col2, _col4=RS_446._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_367] (rows=464045263 width=326) + Conds:RS_445._col2, _col4=RS_448._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 29 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_443] + SHUFFLE [RS_445] PartitionCols:_col2, _col4 - Select Operator [SEL_442] (rows=283691906 width=243) + Select Operator [SEL_444] (rows=283691906 width=243) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_441] (rows=283691906 width=243) + Filter Operator [FIL_443] (rows=283691906 width=243) predicate:(cs_promo_sk is not null and cs_sold_date_sk is not null and cs_catalog_page_sk is not null and cs_item_sk is not null and cs_sold_date_sk BETWEEN DynamicValue(RS_61_date_dim_d_date_sk_min) AND DynamicValue(RS_61_date_dim_d_date_sk_max) and in_bloom_filter(cs_sold_date_sk, DynamicValue(RS_61_date_dim_d_date_sk_bloom_filter))) TableScan [TS_39] (rows=287989836 width=243) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_catalog_page_sk","cs_item_sk","cs_promo_sk","cs_order_number","cs_ext_sales_price","cs_net_profit"] <-Reducer 19 [BROADCAST_EDGE] vectorized - BROADCAST [RS_440] - Group By Operator [GBY_439] (rows=1 width=12) + BROADCAST [RS_442] + Group By Operator [GBY_441] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_405] - Group By Operator [GBY_402] (rows=1 width=12) + SHUFFLE [RS_407] + Group By Operator [GBY_404] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_398] (rows=8116 width=4) + Select Operator [SEL_400] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_394] + Please refer to the previous Select Operator [SEL_396] <-Map 31 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_446] + SHUFFLE [RS_448] PartitionCols:_col0, _col1 - Select Operator [SEL_445] (rows=28798881 width=227) + Select Operator [SEL_447] (rows=28798881 width=227) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_444] (rows=28798881 width=227) + Filter Operator [FIL_446] (rows=28798881 width=227) predicate:(cr_item_sk is not null and cr_order_number is not null) TableScan [TS_42] (rows=28798881 width=227) default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_item_sk","cr_order_number","cr_return_amount","cr_net_loss"] <-Reducer 24 [CONTAINS] vectorized - Reduce Output Operator [RS_470] + Reduce Output Operator [RS_472] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_469] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_468] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_467] (rows=53 width=615) + Top N Key Operator [TNK_471] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_470] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_469] (rows=53 width=615) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_466] (rows=53 width=436) + Group By Operator [GBY_468] (rows=53 width=436) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 23 [SIMPLE_EDGE] SHUFFLE [RS_115] @@ -384,88 +384,88 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_112] (rows=84869669 width=323) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_374] (rows=84869669 width=323) - Conds:RS_109._col2=RS_465._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] + Merge Join Operator [MERGEJOIN_376] (rows=84869669 width=323) + Conds:RS_109._col2=RS_467._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] <-Map 36 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_465] + SHUFFLE [RS_467] PartitionCols:_col0 - Select Operator [SEL_464] (rows=84 width=104) + Select Operator [SEL_466] (rows=84 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_463] (rows=84 width=104) + Filter Operator [FIL_465] (rows=84 width=104) predicate:web_site_sk is not null TableScan [TS_94] (rows=84 width=104) default@web_site,web_site,Tbl:COMPLETE,Col:COMPLETE,Output:["web_site_sk","web_site_id"] <-Reducer 22 [SIMPLE_EDGE] SHUFFLE [RS_109] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_373] (rows=84869669 width=227) - Conds:RS_106._col3=RS_424._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_375] (rows=84869669 width=227) + Conds:RS_106._col3=RS_426._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_424] + SHUFFLE [RS_426] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_421] + Please refer to the previous Select Operator [SEL_423] <-Reducer 21 [SIMPLE_EDGE] SHUFFLE [RS_106] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_372] (rows=84869669 width=231) - Conds:RS_103._col1=RS_419._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_374] (rows=84869669 width=231) + Conds:RS_103._col1=RS_421._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_419] + SHUFFLE [RS_421] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_416] + Please refer to the previous Select Operator [SEL_418] <-Reducer 20 [SIMPLE_EDGE] SHUFFLE [RS_103] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_371] (rows=254608997 width=359) - Conds:RS_100._col0=RS_399._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_373] (rows=254608997 width=359) + Conds:RS_100._col0=RS_401._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_399] + SHUFFLE [RS_401] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_394] + Please refer to the previous Select Operator [SEL_396] <-Reducer 34 [SIMPLE_EDGE] SHUFFLE [RS_100] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_370] (rows=254608997 width=363) - Conds:RS_459._col1, _col4=RS_462._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_372] (rows=254608997 width=363) + Conds:RS_461._col1, _col4=RS_464._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 33 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_459] + SHUFFLE [RS_461] PartitionCols:_col1, _col4 - Select Operator [SEL_458] (rows=143894769 width=243) + Select Operator [SEL_460] (rows=143894769 width=243) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_457] (rows=143894769 width=243) + Filter Operator [FIL_459] (rows=143894769 width=243) predicate:(ws_promo_sk is not null and ws_web_site_sk is not null and ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_101_date_dim_d_date_sk_min) AND DynamicValue(RS_101_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_101_date_dim_d_date_sk_bloom_filter))) TableScan [TS_79] (rows=144002668 width=243) default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_site_sk","ws_promo_sk","ws_order_number","ws_ext_sales_price","ws_net_profit"] <-Reducer 25 [BROADCAST_EDGE] vectorized - BROADCAST [RS_456] - Group By Operator [GBY_455] (rows=1 width=12) + BROADCAST [RS_458] + Group By Operator [GBY_457] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_406] - Group By Operator [GBY_403] (rows=1 width=12) + SHUFFLE [RS_408] + Group By Operator [GBY_405] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_400] (rows=8116 width=4) + Select Operator [SEL_402] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_394] + Please refer to the previous Select Operator [SEL_396] <-Map 35 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_462] + SHUFFLE [RS_464] PartitionCols:_col0, _col1 - Select Operator [SEL_461] (rows=14398467 width=221) + Select Operator [SEL_463] (rows=14398467 width=221) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_460] (rows=14398467 width=221) + Filter Operator [FIL_462] (rows=14398467 width=221) predicate:(wr_item_sk is not null and wr_order_number is not null) TableScan [TS_82] (rows=14398467 width=221) default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_order_number","wr_return_amt","wr_net_loss"] <-Reducer 7 [CONTAINS] vectorized - Reduce Output Operator [RS_432] + Reduce Output Operator [RS_434] PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_431] (rows=59581 width=627) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L - Top N Key Operator [TNK_430] (rows=39721 width=618) - keys:_col0, _col1, 0L,top n:100 - Select Operator [SEL_429] (rows=822 width=617) + Top N Key Operator [TNK_433] (rows=59581 width=627) + keys:_col0, _col1,top n:100 + Group By Operator [GBY_432] (rows=59581 width=627) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"],aggregations:["sum(_col2)","sum(_col3)","sum(_col4)"],keys:_col0, _col1, 0L + Select Operator [SEL_431] (rows=822 width=617) Output:["_col0","_col1","_col2","_col3","_col4"] - Group By Operator [GBY_428] (rows=822 width=436) + Group By Operator [GBY_430] (rows=822 width=436) Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)"],keys:KEY._col0 <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_36] @@ -474,75 +474,75 @@ Stage-0 Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col1)","sum(_col2)","sum(_col3)"],keys:_col0 Select Operator [SEL_33] (rows=270716624 width=305) Output:["_col0","_col1","_col2","_col3"] - Merge Join Operator [MERGEJOIN_364] (rows=270716624 width=305) - Conds:RS_30._col2=RS_427._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] + Merge Join Operator [MERGEJOIN_366] (rows=270716624 width=305) + Conds:RS_30._col2=RS_429._col0(Inner),Output:["_col5","_col6","_col9","_col10","_col15"] <-Map 28 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_427] + SHUFFLE [RS_429] PartitionCols:_col0 - Select Operator [SEL_426] (rows=1704 width=104) + Select Operator [SEL_428] (rows=1704 width=104) Output:["_col0","_col1"] - Filter Operator [FIL_425] (rows=1704 width=104) + Filter Operator [FIL_427] (rows=1704 width=104) predicate:s_store_sk is not null TableScan [TS_15] (rows=1704 width=104) default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_id"] <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_30] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_363] (rows=270716624 width=208) - Conds:RS_27._col3=RS_422._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_365] (rows=270716624 width=208) + Conds:RS_27._col3=RS_424._col0(Inner),Output:["_col2","_col5","_col6","_col9","_col10"] <-Map 27 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_422] + SHUFFLE [RS_424] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_421] + Please refer to the previous Select Operator [SEL_423] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_27] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_362] (rows=270716624 width=212) - Conds:RS_24._col1=RS_417._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_364] (rows=270716624 width=212) + Conds:RS_24._col1=RS_419._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 26 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_417] + SHUFFLE [RS_419] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_416] + Please refer to the previous Select Operator [SEL_418] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_361] (rows=812149846 width=370) - Conds:RS_21._col0=RS_395._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_363] (rows=812149846 width=370) + Conds:RS_21._col0=RS_397._col0(Inner),Output:["_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_395] + SHUFFLE [RS_397] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_394] + Please refer to the previous Select Operator [SEL_396] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_360] (rows=812149846 width=374) - Conds:RS_411._col1, _col4=RS_414._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] + Merge Join Operator [MERGEJOIN_362] (rows=812149846 width=374) + Conds:RS_413._col1, _col4=RS_416._col0, _col1(Left Outer),Output:["_col0","_col1","_col2","_col3","_col5","_col6","_col9","_col10"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_411] + SHUFFLE [RS_413] PartitionCols:_col1, _col4 - Select Operator [SEL_410] (rows=501693263 width=233) + Select Operator [SEL_412] (rows=501693263 width=233) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - Filter Operator [FIL_409] (rows=501693263 width=233) + Filter Operator [FIL_411] (rows=501693263 width=233) predicate:(ss_sold_date_sk is not null and ss_promo_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_22_date_dim_d_date_sk_min) AND DynamicValue(RS_22_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_22_date_dim_d_date_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=233) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_promo_sk","ss_ticket_number","ss_ext_sales_price","ss_net_profit"] <-Reducer 13 [BROADCAST_EDGE] vectorized - BROADCAST [RS_408] - Group By Operator [GBY_407] (rows=1 width=12) + BROADCAST [RS_410] + Group By Operator [GBY_409] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 12 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_404] - Group By Operator [GBY_401] (rows=1 width=12) + SHUFFLE [RS_406] + Group By Operator [GBY_403] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_396] (rows=8116 width=4) + Select Operator [SEL_398] (rows=8116 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_394] + Please refer to the previous Select Operator [SEL_396] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_414] + SHUFFLE [RS_416] PartitionCols:_col0, _col1 - Select Operator [SEL_413] (rows=57591150 width=224) + Select Operator [SEL_415] (rows=57591150 width=224) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_412] (rows=57591150 width=224) + Filter Operator [FIL_414] (rows=57591150 width=224) predicate:(sr_item_sk is not null and sr_ticket_number is not null) TableScan [TS_3] (rows=57591150 width=224) default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_ticket_number","sr_return_amt","sr_net_loss"] diff --git ql/src/test/results/clientpositive/perf/tez/query81.q.out ql/src/test/results/clientpositive/perf/tez/query81.q.out index 7feb6175fe..d9c93e5a4e 100644 --- ql/src/test/results/clientpositive/perf/tez/query81.q.out +++ ql/src/test/results/clientpositive/perf/tez/query81.q.out @@ -87,138 +87,140 @@ Stage-0 limit:-1 Stage-1 Reducer 4 vectorized - File Output Operator [FS_215] - Select Operator [SEL_214] (rows=100 width=1504) + File Output Operator [FS_216] + Select Operator [SEL_215] (rows=100 width=1503) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15"] - Limit [LIM_213] (rows=100 width=1418) + Limit [LIM_214] (rows=100 width=1417) Number of rows:100 - Select Operator [SEL_212] (rows=1545467 width=1418) + Select Operator [SEL_213] (rows=1545467 width=1416) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_66] - Select Operator [SEL_65] (rows=1545467 width=1418) + Select Operator [SEL_65] (rows=1545467 width=1416) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14"] - Merge Join Operator [MERGEJOIN_181] (rows=1545467 width=1418) - Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col19"] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_63] - PartitionCols:_col0 - Select Operator [SEL_58] (rows=1545467 width=227) - Output:["_col0","_col2"] - Filter Operator [FIL_57] (rows=1545467 width=227) - predicate:(_col2 > _col3) - Merge Join Operator [MERGEJOIN_180] (rows=4636401 width=227) - Conds:RS_205._col1=RS_211._col1(Inner),Output:["_col0","_col2","_col3"] - <-Reducer 13 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_211] - PartitionCols:_col1 - Select Operator [SEL_210] (rows=12 width=198) - Output:["_col0","_col1"] - Filter Operator [FIL_209] (rows=12 width=206) - predicate:(_col1 is not null and _col2 is not null) - Group By Operator [GBY_208] (rows=12 width=206) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 - Select Operator [SEL_207] (rows=5266632 width=201) - Output:["_col0","_col2"] - Group By Operator [GBY_206] (rows=5266632 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col0 - Group By Operator [GBY_44] (rows=8749496 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_179] (rows=8749496 width=194) - Conds:RS_40._col2=RS_201._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_201] - PartitionCols:_col0 - Select Operator [SEL_199] (rows=40000000 width=90) - Output:["_col0","_col1"] - Filter Operator [FIL_198] (rows=40000000 width=90) - predicate:(ca_address_sk is not null and ca_state is not null) - TableScan [TS_12] (rows=40000000 width=90) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_178] (rows=8749496 width=112) - Conds:RS_193._col0=RS_197._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_197] - PartitionCols:_col0 - Select Operator [SEL_195] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_194] (rows=652 width=8) - predicate:((d_year = 1998) and d_date_sk is not null) - TableScan [TS_9] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_193] - PartitionCols:_col0 - Select Operator [SEL_191] (rows=28221532 width=121) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_189] (rows=28221532 width=121) - predicate:(cr_returning_addr_sk is not null and cr_returned_date_sk is not null) - TableScan [TS_6] (rows=28798881 width=121) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_returning_customer_sk","cr_returning_addr_sk","cr_return_amt_inc_tax"] - <-Reducer 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_205] - PartitionCols:_col1 - Filter Operator [FIL_204] (rows=4636401 width=201) - predicate:_col2 is not null - Select Operator [SEL_203] (rows=4636401 width=201) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_202] (rows=4636401 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1 - Group By Operator [GBY_22] (rows=8574602 width=201) - Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 - Merge Join Operator [MERGEJOIN_177] (rows=8574602 width=194) - Conds:RS_18._col2=RS_200._col0(Inner),Output:["_col1","_col3","_col6"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_200] + Top N Key Operator [TNK_105] (rows=1545467 width=1418) + keys:_col1, _col3, _col4, _col5, _col7, _col8, _col9, _col10, _col11, _col12, _col13, _col14, _col15, _col16, _col19,top n:100 + Merge Join Operator [MERGEJOIN_182] (rows=1545467 width=1418) + Conds:RS_62._col0=RS_63._col0(Inner),Output:["_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16","_col19"] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_63] + PartitionCols:_col0 + Select Operator [SEL_58] (rows=1545467 width=227) + Output:["_col0","_col2"] + Filter Operator [FIL_57] (rows=1545467 width=227) + predicate:(_col2 > _col3) + Merge Join Operator [MERGEJOIN_181] (rows=4636401 width=227) + Conds:RS_206._col1=RS_212._col1(Inner),Output:["_col0","_col2","_col3"] + <-Reducer 13 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_212] + PartitionCols:_col1 + Select Operator [SEL_211] (rows=12 width=198) + Output:["_col0","_col1"] + Filter Operator [FIL_210] (rows=12 width=206) + predicate:(_col1 is not null and _col2 is not null) + Group By Operator [GBY_209] (rows=12 width=206) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col2)","count(_col2)"],keys:_col0 + Select Operator [SEL_208] (rows=5266632 width=201) + Output:["_col0","_col2"] + Group By Operator [GBY_207] (rows=5266632 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_45] PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_199] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_176] (rows=8574602 width=112) - Conds:RS_192._col0=RS_196._col0(Inner),Output:["_col1","_col2","_col3"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_196] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_195] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_192] - PartitionCols:_col0 - Select Operator [SEL_190] (rows=27657410 width=121) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_188] (rows=27657410 width=121) - predicate:(cr_returning_addr_sk is not null and cr_returning_customer_sk is not null and cr_returned_date_sk is not null) - Please refer to the previous TableScan [TS_6] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_62] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_175] (rows=1568628 width=1310) - Conds:RS_184._col2=RS_187._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_184] - PartitionCols:_col2 - Select Operator [SEL_183] (rows=80000000 width=375) - Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - Filter Operator [FIL_182] (rows=80000000 width=375) - predicate:(c_current_addr_sk is not null and c_customer_sk is not null) - TableScan [TS_0] (rows=80000000 width=375) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_187] - PartitionCols:_col0 - Select Operator [SEL_186] (rows=784314 width=941) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - Filter Operator [FIL_185] (rows=784314 width=1027) - predicate:((ca_state = 'IL') and ca_address_sk is not null) - TableScan [TS_3] (rows=40000000 width=1027) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_street_number","ca_street_name","ca_street_type","ca_suite_number","ca_city","ca_county","ca_state","ca_zip","ca_country","ca_gmt_offset","ca_location_type"] + Group By Operator [GBY_44] (rows=8749496 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_180] (rows=8749496 width=194) + Conds:RS_40._col2=RS_202._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_202] + PartitionCols:_col0 + Select Operator [SEL_200] (rows=40000000 width=90) + Output:["_col0","_col1"] + Filter Operator [FIL_199] (rows=40000000 width=90) + predicate:(ca_address_sk is not null and ca_state is not null) + TableScan [TS_12] (rows=40000000 width=90) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_179] (rows=8749496 width=112) + Conds:RS_194._col0=RS_198._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_198] + PartitionCols:_col0 + Select Operator [SEL_196] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_195] (rows=652 width=8) + predicate:((d_year = 1998) and d_date_sk is not null) + TableScan [TS_9] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_194] + PartitionCols:_col0 + Select Operator [SEL_192] (rows=28221532 width=121) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_190] (rows=28221532 width=121) + predicate:(cr_returning_addr_sk is not null and cr_returned_date_sk is not null) + TableScan [TS_6] (rows=28798881 width=121) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_returning_customer_sk","cr_returning_addr_sk","cr_return_amt_inc_tax"] + <-Reducer 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_206] + PartitionCols:_col1 + Filter Operator [FIL_205] (rows=4636401 width=201) + predicate:_col2 is not null + Select Operator [SEL_204] (rows=4636401 width=201) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_203] (rows=4636401 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1 + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1 + Group By Operator [GBY_22] (rows=8574602 width=201) + Output:["_col0","_col1","_col2"],aggregations:["sum(_col3)"],keys:_col6, _col1 + Merge Join Operator [MERGEJOIN_178] (rows=8574602 width=194) + Conds:RS_18._col2=RS_201._col0(Inner),Output:["_col1","_col3","_col6"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_201] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_200] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_177] (rows=8574602 width=112) + Conds:RS_193._col0=RS_197._col0(Inner),Output:["_col1","_col2","_col3"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_197] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_196] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_193] + PartitionCols:_col0 + Select Operator [SEL_191] (rows=27657410 width=121) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_189] (rows=27657410 width=121) + predicate:(cr_returning_addr_sk is not null and cr_returning_customer_sk is not null and cr_returned_date_sk is not null) + Please refer to the previous TableScan [TS_6] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_62] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_176] (rows=1568628 width=1310) + Conds:RS_185._col2=RS_188._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col7","_col8","_col9","_col10","_col11","_col12","_col13","_col14","_col15","_col16"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_185] + PartitionCols:_col2 + Select Operator [SEL_184] (rows=80000000 width=375) + Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Filter Operator [FIL_183] (rows=80000000 width=375) + predicate:(c_current_addr_sk is not null and c_customer_sk is not null) + TableScan [TS_0] (rows=80000000 width=375) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_sk","c_customer_id","c_current_addr_sk","c_salutation","c_first_name","c_last_name"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_188] + PartitionCols:_col0 + Select Operator [SEL_187] (rows=784314 width=941) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] + Filter Operator [FIL_186] (rows=784314 width=1027) + predicate:((ca_state = 'IL') and ca_address_sk is not null) + TableScan [TS_3] (rows=40000000 width=1027) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_street_number","ca_street_name","ca_street_type","ca_suite_number","ca_city","ca_county","ca_state","ca_zip","ca_country","ca_gmt_offset","ca_location_type"] diff --git ql/src/test/results/clientpositive/perf/tez/query82.q.out ql/src/test/results/clientpositive/perf/tez/query82.q.out index c7721acffe..07f1943b3d 100644 --- ql/src/test/results/clientpositive/perf/tez/query82.q.out +++ ql/src/test/results/clientpositive/perf/tez/query82.q.out @@ -56,78 +56,78 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_101] - Limit [LIM_100] (rows=1 width=396) + File Output Operator [FS_106] + Limit [LIM_105] (rows=1 width=396) Number of rows:100 - Select Operator [SEL_99] (rows=1 width=396) + Select Operator [SEL_104] (rows=1 width=396) Output:["_col0","_col1","_col2"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_98] - Group By Operator [GBY_97] (rows=1 width=396) + SHUFFLE [RS_103] + Group By Operator [GBY_102] (rows=1 width=396) Output:["_col0","_col1","_col2"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_23] (rows=2 width=396) Output:["_col0","_col1","_col2"],keys:_col2, _col3, _col4 - Top N Key Operator [TNK_43] (rows=11627 width=396) + Top N Key Operator [TNK_48] (rows=11627 width=396) keys:_col2, _col3, _col4,top n:100 - Merge Join Operator [MERGEJOIN_79] (rows=11627 width=396) + Merge Join Operator [MERGEJOIN_84] (rows=11627 width=396) Conds:RS_19._col1=RS_20._col1(Inner),Output:["_col2","_col3","_col4"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_19] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_77] (rows=3564040 width=400) - Conds:RS_90._col0=RS_82._col0(Inner),Output:["_col1","_col2","_col3","_col4"] + Merge Join Operator [MERGEJOIN_82] (rows=3564040 width=400) + Conds:RS_95._col0=RS_87._col0(Inner),Output:["_col1","_col2","_col3","_col4"] <-Map 6 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_82] + PARTITION_ONLY_SHUFFLE [RS_87] PartitionCols:_col0 - Select Operator [SEL_81] (rows=297 width=400) + Select Operator [SEL_86] (rows=297 width=400) Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_80] (rows=297 width=404) + Filter Operator [FIL_85] (rows=297 width=404) predicate:(i_current_price BETWEEN 30 AND 60 and (i_manufact_id) IN (437, 129, 727, 663) and i_item_sk is not null) TableScan [TS_3] (rows=462000 width=403) default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id","i_item_desc","i_current_price","i_manufact_id"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_90] + SHUFFLE [RS_95] PartitionCols:_col0 - Select Operator [SEL_89] (rows=575995635 width=4) + Select Operator [SEL_94] (rows=575995635 width=4) Output:["_col0"] - Filter Operator [FIL_88] (rows=575995635 width=4) + Filter Operator [FIL_93] (rows=575995635 width=4) predicate:(ss_item_sk is not null and ss_item_sk BETWEEN DynamicValue(RS_17_item_i_item_sk_min) AND DynamicValue(RS_17_item_i_item_sk_max) and in_bloom_filter(ss_item_sk, DynamicValue(RS_17_item_i_item_sk_bloom_filter))) TableScan [TS_0] (rows=575995635 width=4) default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk"] <-Reducer 7 [BROADCAST_EDGE] vectorized - BROADCAST [RS_87] - Group By Operator [GBY_86] (rows=1 width=12) + BROADCAST [RS_92] + Group By Operator [GBY_91] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 6 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_85] - Group By Operator [GBY_84] (rows=1 width=12) + PARTITION_ONLY_SHUFFLE [RS_90] + Group By Operator [GBY_89] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_83] (rows=297 width=4) + Select Operator [SEL_88] (rows=297 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_81] + Please refer to the previous Select Operator [SEL_86] <-Reducer 9 [SIMPLE_EDGE] SHUFFLE [RS_20] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_78] (rows=1879072 width=4) - Conds:RS_93._col0=RS_96._col0(Inner),Output:["_col1"] + Merge Join Operator [MERGEJOIN_83] (rows=1879072 width=4) + Conds:RS_98._col0=RS_101._col0(Inner),Output:["_col1"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_96] + SHUFFLE [RS_101] PartitionCols:_col0 - Select Operator [SEL_95] (rows=8116 width=4) + Select Operator [SEL_100] (rows=8116 width=4) Output:["_col0"] - Filter Operator [FIL_94] (rows=8116 width=98) + Filter Operator [FIL_99] (rows=8116 width=98) predicate:(CAST( d_date AS TIMESTAMP) BETWEEN TIMESTAMP'2002-05-30 00:00:00' AND TIMESTAMP'2002-07-29 00:00:00' and d_date_sk is not null) TableScan [TS_9] (rows=73049 width=98) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_93] + SHUFFLE [RS_98] PartitionCols:_col0 - Select Operator [SEL_92] (rows=16912800 width=8) + Select Operator [SEL_97] (rows=16912800 width=8) Output:["_col0","_col1"] - Filter Operator [FIL_91] (rows=16912800 width=11) + Filter Operator [FIL_96] (rows=16912800 width=11) predicate:(inv_quantity_on_hand BETWEEN 100 AND 500 and inv_item_sk is not null and inv_date_sk is not null) TableScan [TS_6] (rows=37584000 width=11) default@inventory,inventory,Tbl:COMPLETE,Col:COMPLETE,Output:["inv_date_sk","inv_item_sk","inv_quantity_on_hand"] diff --git ql/src/test/results/clientpositive/perf/tez/query83.q.out ql/src/test/results/clientpositive/perf/tez/query83.q.out index 54c1ba6161..112381c662 100644 --- ql/src/test/results/clientpositive/perf/tez/query83.q.out +++ ql/src/test/results/clientpositive/perf/tez/query83.q.out @@ -166,175 +166,177 @@ Stage-0 limit:100 Stage-1 Reducer 7 vectorized - File Output Operator [FS_401] - Limit [LIM_400] (rows=60 width=260) + File Output Operator [FS_402] + Limit [LIM_401] (rows=60 width=260) Number of rows:100 - Select Operator [SEL_399] (rows=60 width=260) + Select Operator [SEL_400] (rows=60 width=260) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 6 [SIMPLE_EDGE] SHUFFLE [RS_127] Select Operator [SEL_126] (rows=60 width=260) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Merge Join Operator [MERGEJOIN_363] (rows=60 width=148) - Conds:RS_123._col0=RS_398._col0(Inner),Output:["_col0","_col1","_col2","_col4","_col5","_col7","_col8"] - <-Reducer 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_398] - PartitionCols:_col0 - Select Operator [SEL_397] (rows=310774 width=116) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_396] (rows=310774 width=108) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_117] + Top N Key Operator [TNK_207] (rows=60 width=148) + keys:_col0, _col4,top n:100 + Merge Join Operator [MERGEJOIN_364] (rows=60 width=148) + Conds:RS_123._col0=RS_399._col0(Inner),Output:["_col0","_col1","_col2","_col4","_col5","_col7","_col8"] + <-Reducer 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_399] + PartitionCols:_col0 + Select Operator [SEL_398] (rows=310774 width=116) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_397] (rows=310774 width=108) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_117] + PartitionCols:_col0 + Group By Operator [GBY_116] (rows=1864644 width=108) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 + Merge Join Operator [MERGEJOIN_362] (rows=13749816 width=103) + Conds:RS_112._col0=RS_113._col0(Inner),Output:["_col2","_col4"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_113] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_353] (rows=2 width=4) + Conds:RS_375._col1=RS_384._col0(Inner),Output:["_col0"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_375] + PartitionCols:_col1 + Select Operator [SEL_374] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_373] (rows=73049 width=98) + predicate:(d_date is not null and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] + <-Reducer 19 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_384] + PartitionCols:_col0 + Group By Operator [GBY_383] (rows=2 width=94) + Output:["_col0"],keys:KEY._col0 + <-Reducer 18 [SIMPLE_EDGE] + SHUFFLE [RS_22] + PartitionCols:_col0 + Group By Operator [GBY_21] (rows=2 width=94) + Output:["_col0"],keys:_col0 + Merge Join Operator [MERGEJOIN_352] (rows=5 width=94) + Conds:RS_378._col1=RS_382._col0(Left Semi),Output:["_col0"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_378] + PartitionCols:_col1 + Select Operator [SEL_377] (rows=73049 width=98) + Output:["_col0","_col1"] + Filter Operator [FIL_376] (rows=73049 width=98) + predicate:(d_week_seq is not null and d_date is not null) + TableScan [TS_9] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] + <-Map 20 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_382] + PartitionCols:_col0 + Group By Operator [GBY_381] (rows=1 width=4) + Output:["_col0"],keys:_col0 + Select Operator [SEL_380] (rows=2 width=4) + Output:["_col0"] + Filter Operator [FIL_379] (rows=2 width=98) + predicate:((d_date) IN ('1998-01-02', '1998-10-15', '1998-11-10') and d_week_seq is not null) + TableScan [TS_12] (rows=73049 width=98) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_112] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_357] (rows=13749816 width=107) + Conds:RS_396._col1=RS_372._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_372] + PartitionCols:_col0 + Select Operator [SEL_369] (rows=462000 width=104) + Output:["_col0","_col1"] + Filter Operator [FIL_368] (rows=462000 width=104) + predicate:(i_item_sk is not null and i_item_id is not null) + TableScan [TS_3] (rows=462000 width=104) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] + <-Map 22 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_396] + PartitionCols:_col1 + Select Operator [SEL_395] (rows=13749816 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_394] (rows=13749816 width=11) + predicate:(wr_returned_date_sk is not null and wr_item_sk is not null) + TableScan [TS_80] (rows=14398467 width=11) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_item_sk","wr_return_quantity"] + <-Reducer 5 [SIMPLE_EDGE] + SHUFFLE [RS_123] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_363] (rows=60 width=132) + Conds:RS_387._col0=RS_393._col0(Inner),Output:["_col0","_col1","_col2","_col4","_col5"] + <-Reducer 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_393] PartitionCols:_col0 - Group By Operator [GBY_116] (rows=1864644 width=108) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 - Merge Join Operator [MERGEJOIN_361] (rows=13749816 width=103) - Conds:RS_112._col0=RS_113._col0(Inner),Output:["_col2","_col4"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_113] + Select Operator [SEL_392] (rows=310774 width=116) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_391] (rows=310774 width=108) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_77] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_352] (rows=2 width=4) - Conds:RS_374._col1=RS_383._col0(Inner),Output:["_col0"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_374] - PartitionCols:_col1 - Select Operator [SEL_373] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_372] (rows=73049 width=98) - predicate:(d_date is not null and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_date"] - <-Reducer 19 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_383] - PartitionCols:_col0 - Group By Operator [GBY_382] (rows=2 width=94) - Output:["_col0"],keys:KEY._col0 - <-Reducer 18 [SIMPLE_EDGE] - SHUFFLE [RS_22] - PartitionCols:_col0 - Group By Operator [GBY_21] (rows=2 width=94) - Output:["_col0"],keys:_col0 - Merge Join Operator [MERGEJOIN_351] (rows=5 width=94) - Conds:RS_377._col1=RS_381._col0(Left Semi),Output:["_col0"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_377] - PartitionCols:_col1 - Select Operator [SEL_376] (rows=73049 width=98) - Output:["_col0","_col1"] - Filter Operator [FIL_375] (rows=73049 width=98) - predicate:(d_week_seq is not null and d_date is not null) - TableScan [TS_9] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] - <-Map 20 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_381] - PartitionCols:_col0 - Group By Operator [GBY_380] (rows=1 width=4) - Output:["_col0"],keys:_col0 - Select Operator [SEL_379] (rows=2 width=4) - Output:["_col0"] - Filter Operator [FIL_378] (rows=2 width=98) - predicate:((d_date) IN ('1998-01-02', '1998-10-15', '1998-11-10') and d_week_seq is not null) - TableScan [TS_12] (rows=73049 width=98) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date","d_week_seq"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_112] + Group By Operator [GBY_76] (rows=7147802 width=108) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 + Merge Join Operator [MERGEJOIN_361] (rows=55578005 width=103) + Conds:RS_72._col0=RS_73._col0(Inner),Output:["_col2","_col4"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_73] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_353] + <-Reducer 9 [SIMPLE_EDGE] + SHUFFLE [RS_72] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_354] (rows=55578005 width=107) + Conds:RS_390._col1=RS_371._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_371] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_369] + <-Map 21 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_390] + PartitionCols:_col1 + Select Operator [SEL_389] (rows=55578005 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_388] (rows=55578005 width=11) + predicate:(sr_returned_date_sk is not null and sr_item_sk is not null) + TableScan [TS_40] (rows=57591150 width=11) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_return_quantity"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_387] + PartitionCols:_col0 + Select Operator [SEL_386] (rows=60 width=116) + Output:["_col0","_col1","_col2"] + Group By Operator [GBY_385] (rows=60 width=108) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_37] PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_356] (rows=13749816 width=107) - Conds:RS_395._col1=RS_371._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_371] - PartitionCols:_col0 - Select Operator [SEL_368] (rows=462000 width=104) - Output:["_col0","_col1"] - Filter Operator [FIL_367] (rows=462000 width=104) - predicate:(i_item_sk is not null and i_item_id is not null) - TableScan [TS_3] (rows=462000 width=104) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_item_id"] - <-Map 22 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_395] - PartitionCols:_col1 - Select Operator [SEL_394] (rows=13749816 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_393] (rows=13749816 width=11) - predicate:(wr_returned_date_sk is not null and wr_item_sk is not null) - TableScan [TS_80] (rows=14398467 width=11) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_returned_date_sk","wr_item_sk","wr_return_quantity"] - <-Reducer 5 [SIMPLE_EDGE] - SHUFFLE [RS_123] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_362] (rows=60 width=132) - Conds:RS_386._col0=RS_392._col0(Inner),Output:["_col0","_col1","_col2","_col4","_col5"] - <-Reducer 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_392] - PartitionCols:_col0 - Select Operator [SEL_391] (rows=310774 width=116) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_390] (rows=310774 width=108) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_77] - PartitionCols:_col0 - Group By Operator [GBY_76] (rows=7147802 width=108) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 - Merge Join Operator [MERGEJOIN_360] (rows=55578005 width=103) - Conds:RS_72._col0=RS_73._col0(Inner),Output:["_col2","_col4"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_73] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_352] - <-Reducer 9 [SIMPLE_EDGE] - SHUFFLE [RS_72] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_353] (rows=55578005 width=107) - Conds:RS_389._col1=RS_370._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_370] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_368] - <-Map 21 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_389] - PartitionCols:_col1 - Select Operator [SEL_388] (rows=55578005 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_387] (rows=55578005 width=11) - predicate:(sr_returned_date_sk is not null and sr_item_sk is not null) - TableScan [TS_40] (rows=57591150 width=11) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_returned_date_sk","sr_item_sk","sr_return_quantity"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_386] - PartitionCols:_col0 - Select Operator [SEL_385] (rows=60 width=116) - Output:["_col0","_col1","_col2"] - Group By Operator [GBY_384] (rows=60 width=108) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_37] - PartitionCols:_col0 - Group By Operator [GBY_36] (rows=60 width=108) - Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 - Merge Join Operator [MERGEJOIN_359] (rows=5478 width=100) - Conds:RS_32._col0=RS_33._col0(Inner),Output:["_col2","_col4"] - <-Reducer 16 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col0 - Please refer to the previous Merge Join Operator [MERGEJOIN_352] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_350] (rows=28798881 width=107) - Conds:RS_366._col1=RS_369._col0(Inner),Output:["_col0","_col2","_col4"] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_369] - PartitionCols:_col0 - Please refer to the previous Select Operator [SEL_368] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_366] - PartitionCols:_col1 - Select Operator [SEL_365] (rows=28798881 width=11) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_364] (rows=28798881 width=11) - predicate:(cr_item_sk is not null and cr_returned_date_sk is not null) - TableScan [TS_0] (rows=28798881 width=11) - default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_item_sk","cr_return_quantity"] + Group By Operator [GBY_36] (rows=60 width=108) + Output:["_col0","_col1"],aggregations:["sum(_col2)"],keys:_col4 + Merge Join Operator [MERGEJOIN_360] (rows=5478 width=100) + Conds:RS_32._col0=RS_33._col0(Inner),Output:["_col2","_col4"] + <-Reducer 16 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col0 + Please refer to the previous Merge Join Operator [MERGEJOIN_353] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_351] (rows=28798881 width=107) + Conds:RS_367._col1=RS_370._col0(Inner),Output:["_col0","_col2","_col4"] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_370] + PartitionCols:_col0 + Please refer to the previous Select Operator [SEL_369] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_367] + PartitionCols:_col1 + Select Operator [SEL_366] (rows=28798881 width=11) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_365] (rows=28798881 width=11) + predicate:(cr_item_sk is not null and cr_returned_date_sk is not null) + TableScan [TS_0] (rows=28798881 width=11) + default@catalog_returns,catalog_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["cr_returned_date_sk","cr_item_sk","cr_return_quantity"] diff --git ql/src/test/results/clientpositive/perf/tez/query84.q.out ql/src/test/results/clientpositive/perf/tez/query84.q.out index 4fd546bc07..714a7ae1fb 100644 --- ql/src/test/results/clientpositive/perf/tez/query84.q.out +++ ql/src/test/results/clientpositive/perf/tez/query84.q.out @@ -67,89 +67,91 @@ Stage-0 limit:-1 Stage-1 Reducer 4 vectorized - File Output Operator [FS_141] - Limit [LIM_140] (rows=100 width=384) + File Output Operator [FS_142] + Limit [LIM_141] (rows=100 width=384) Number of rows:100 - Select Operator [SEL_139] (rows=2645278 width=384) + Select Operator [SEL_140] (rows=2645278 width=384) Output:["_col0","_col1"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_36] Select Operator [SEL_35] (rows=2645278 width=384) Output:["_col1","_col2"] - Merge Join Operator [MERGEJOIN_120] (rows=2645278 width=284) - Conds:RS_32._col1=RS_33._col1(Inner),Output:["_col2","_col6"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_32] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_116] (rows=56363634 width=4) - Conds:RS_123._col0=RS_126._col0(Inner),Output:["_col1"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_123] - PartitionCols:_col0 - Select Operator [SEL_122] (rows=55577698 width=3) - Output:["_col0"] - Filter Operator [FIL_121] (rows=55577698 width=3) - predicate:sr_cdemo_sk is not null - TableScan [TS_0] (rows=57591150 width=3) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_cdemo_sk"] - <-Map 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_126] - PartitionCols:_col0 - Select Operator [SEL_125] (rows=1861800 width=4) - Output:["_col0"] - Filter Operator [FIL_124] (rows=1861800 width=4) - predicate:cd_demo_sk is not null - TableScan [TS_3] (rows=1861800 width=4) - default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] - <-Reducer 8 [SIMPLE_EDGE] - SHUFFLE [RS_33] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_119] (rows=83148 width=284) - Conds:RS_25._col2=RS_26._col0(Inner),Output:["_col0","_col1","_col4"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_26] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_118] (rows=2161 width=4) - Conds:RS_135._col1=RS_138._col0(Inner),Output:["_col0"] - <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_135] - PartitionCols:_col1 - Select Operator [SEL_134] (rows=7200 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_133] (rows=7200 width=8) - predicate:(hd_demo_sk is not null and hd_income_band_sk is not null) - TableScan [TS_12] (rows=7200 width=8) - default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_income_band_sk"] - <-Map 12 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_138] - PartitionCols:_col0 - Select Operator [SEL_137] (rows=6 width=4) - Output:["_col0"] - Filter Operator [FIL_136] (rows=6 width=12) - predicate:((ib_lower_bound >= 32287) and (ib_upper_bound <= 82287) and ib_income_band_sk is not null) - TableScan [TS_15] (rows=20 width=12) - default@income_band,income_band,Tbl:COMPLETE,Col:COMPLETE,Output:["ib_income_band_sk","ib_lower_bound","ib_upper_bound"] - <-Reducer 7 [SIMPLE_EDGE] - SHUFFLE [RS_25] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_117] (rows=83148 width=284) - Conds:RS_129._col3=RS_132._col0(Inner),Output:["_col0","_col1","_col2","_col4"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_129] - PartitionCols:_col3 - Select Operator [SEL_128] (rows=74500295 width=295) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_127] (rows=74500295 width=291) - predicate:(c_current_hdemo_sk is not null and c_current_cdemo_sk is not null and c_current_addr_sk is not null) - TableScan [TS_6] (rows=80000000 width=291) - default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_id","c_current_cdemo_sk","c_current_hdemo_sk","c_current_addr_sk","c_first_name","c_last_name"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_132] - PartitionCols:_col0 - Select Operator [SEL_131] (rows=44643 width=4) - Output:["_col0"] - Filter Operator [FIL_130] (rows=44643 width=97) - predicate:((ca_city = 'Hopewell') and ca_address_sk is not null) - TableScan [TS_9] (rows=40000000 width=97) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] + Top N Key Operator [TNK_63] (rows=2645278 width=284) + keys:_col2,top n:100 + Merge Join Operator [MERGEJOIN_121] (rows=2645278 width=284) + Conds:RS_32._col1=RS_33._col1(Inner),Output:["_col2","_col6"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_32] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_117] (rows=56363634 width=4) + Conds:RS_124._col0=RS_127._col0(Inner),Output:["_col1"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_124] + PartitionCols:_col0 + Select Operator [SEL_123] (rows=55577698 width=3) + Output:["_col0"] + Filter Operator [FIL_122] (rows=55577698 width=3) + predicate:sr_cdemo_sk is not null + TableScan [TS_0] (rows=57591150 width=3) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_cdemo_sk"] + <-Map 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_127] + PartitionCols:_col0 + Select Operator [SEL_126] (rows=1861800 width=4) + Output:["_col0"] + Filter Operator [FIL_125] (rows=1861800 width=4) + predicate:cd_demo_sk is not null + TableScan [TS_3] (rows=1861800 width=4) + default@customer_demographics,customer_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk"] + <-Reducer 8 [SIMPLE_EDGE] + SHUFFLE [RS_33] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_120] (rows=83148 width=284) + Conds:RS_25._col2=RS_26._col0(Inner),Output:["_col0","_col1","_col4"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_26] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_119] (rows=2161 width=4) + Conds:RS_136._col1=RS_139._col0(Inner),Output:["_col0"] + <-Map 10 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_136] + PartitionCols:_col1 + Select Operator [SEL_135] (rows=7200 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_134] (rows=7200 width=8) + predicate:(hd_demo_sk is not null and hd_income_band_sk is not null) + TableScan [TS_12] (rows=7200 width=8) + default@household_demographics,household_demographics,Tbl:COMPLETE,Col:COMPLETE,Output:["hd_demo_sk","hd_income_band_sk"] + <-Map 12 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_139] + PartitionCols:_col0 + Select Operator [SEL_138] (rows=6 width=4) + Output:["_col0"] + Filter Operator [FIL_137] (rows=6 width=12) + predicate:((ib_lower_bound >= 32287) and (ib_upper_bound <= 82287) and ib_income_band_sk is not null) + TableScan [TS_15] (rows=20 width=12) + default@income_band,income_band,Tbl:COMPLETE,Col:COMPLETE,Output:["ib_income_band_sk","ib_lower_bound","ib_upper_bound"] + <-Reducer 7 [SIMPLE_EDGE] + SHUFFLE [RS_25] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_118] (rows=83148 width=284) + Conds:RS_130._col3=RS_133._col0(Inner),Output:["_col0","_col1","_col2","_col4"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_130] + PartitionCols:_col3 + Select Operator [SEL_129] (rows=74500295 width=295) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_128] (rows=74500295 width=291) + predicate:(c_current_hdemo_sk is not null and c_current_cdemo_sk is not null and c_current_addr_sk is not null) + TableScan [TS_6] (rows=80000000 width=291) + default@customer,customer,Tbl:COMPLETE,Col:COMPLETE,Output:["c_customer_id","c_current_cdemo_sk","c_current_hdemo_sk","c_current_addr_sk","c_first_name","c_last_name"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_133] + PartitionCols:_col0 + Select Operator [SEL_132] (rows=44643 width=4) + Output:["_col0"] + Filter Operator [FIL_131] (rows=44643 width=97) + predicate:((ca_city = 'Hopewell') and ca_address_sk is not null) + TableScan [TS_9] (rows=40000000 width=97) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_city"] diff --git ql/src/test/results/clientpositive/perf/tez/query85.q.out ql/src/test/results/clientpositive/perf/tez/query85.q.out index c411a92145..6e1a56248b 100644 --- ql/src/test/results/clientpositive/perf/tez/query85.q.out +++ ql/src/test/results/clientpositive/perf/tez/query85.q.out @@ -200,136 +200,138 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_237] - Limit [LIM_236] (rows=72 width=832) + File Output Operator [FS_239] + Limit [LIM_238] (rows=72 width=832) Number of rows:100 - Select Operator [SEL_235] (rows=72 width=832) + Select Operator [SEL_237] (rows=72 width=832) Output:["_col0","_col1","_col2","_col3"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_234] - Select Operator [SEL_233] (rows=72 width=832) + SHUFFLE [RS_236] + Select Operator [SEL_235] (rows=72 width=832) Output:["_col4","_col5","_col6","_col7"] - Group By Operator [GBY_232] (rows=72 width=353) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)"],keys:KEY._col0 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_50] - PartitionCols:_col0 - Group By Operator [GBY_49] (rows=576 width=353) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","count(_col4)","sum(_col28)","count(_col28)","sum(_col27)","count(_col27)"],keys:_col37 - Merge Join Operator [MERGEJOIN_203] (rows=5749608 width=319) - Conds:RS_45._col2=RS_231._col0(Inner),Output:["_col4","_col27","_col28","_col37"] - <-Map 17 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_231] - PartitionCols:_col0 - Select Operator [SEL_230] (rows=4602 width=4) - Output:["_col0"] - Filter Operator [FIL_229] (rows=4602 width=4) - predicate:wp_web_page_sk is not null - TableScan [TS_34] (rows=4602 width=4) - default@web_page,web_page,Tbl:COMPLETE,Col:COMPLETE,Output:["wp_web_page_sk"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_45] - PartitionCols:_col2 - Filter Operator [FIL_43] (rows=5749608 width=383) - predicate:(((_col30 and _col5) or (_col31 and _col6) or (_col32 and _col7)) and ((_col15 and _col16 and _col8) or (_col17 and _col18 and _col9) or (_col19 and _col20 and _col10))) - Merge Join Operator [MERGEJOIN_202] (rows=20443061 width=383) - Conds:RS_40._col1, _col3=RS_41._col9, _col14(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col15","_col16","_col17","_col18","_col19","_col20","_col27","_col28","_col30","_col31","_col32","_col37"] - <-Reducer 13 [SIMPLE_EDGE] - SHUFFLE [RS_41] - PartitionCols:_col9, _col14 - Select Operator [SEL_33] (rows=2086007 width=307) - Output:["_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col14","_col15","_col16","_col18","_col19","_col20","_col25"] - Merge Join Operator [MERGEJOIN_201] (rows=2086007 width=307) - Conds:RS_30._col4=RS_228._col0(Inner),Output:["_col0","_col5","_col6","_col7","_col9","_col10","_col11","_col18","_col19","_col20","_col21","_col22","_col23","_col25"] - <-Map 16 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_228] + Top N Key Operator [TNK_234] (rows=72 width=353) + keys:substr(_col0, 1, 20), (UDFToDouble(_col1) / _col2), (_col3 / _col4), (_col5 / _col6),top n:100 + Group By Operator [GBY_233] (rows=72 width=353) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)","sum(VALUE._col2)","count(VALUE._col3)","sum(VALUE._col4)","count(VALUE._col5)"],keys:KEY._col0 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_50] + PartitionCols:_col0 + Group By Operator [GBY_49] (rows=576 width=353) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col4)","count(_col4)","sum(_col28)","count(_col28)","sum(_col27)","count(_col27)"],keys:_col37 + Merge Join Operator [MERGEJOIN_204] (rows=5749608 width=319) + Conds:RS_45._col2=RS_232._col0(Inner),Output:["_col4","_col27","_col28","_col37"] + <-Map 17 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_232] + PartitionCols:_col0 + Select Operator [SEL_231] (rows=4602 width=4) + Output:["_col0"] + Filter Operator [FIL_230] (rows=4602 width=4) + predicate:wp_web_page_sk is not null + TableScan [TS_34] (rows=4602 width=4) + default@web_page,web_page,Tbl:COMPLETE,Col:COMPLETE,Output:["wp_web_page_sk"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_45] + PartitionCols:_col2 + Filter Operator [FIL_43] (rows=5749608 width=383) + predicate:(((_col30 and _col5) or (_col31 and _col6) or (_col32 and _col7)) and ((_col15 and _col16 and _col8) or (_col17 and _col18 and _col9) or (_col19 and _col20 and _col10))) + Merge Join Operator [MERGEJOIN_203] (rows=20443061 width=383) + Conds:RS_40._col1, _col3=RS_41._col9, _col14(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col9","_col10","_col15","_col16","_col17","_col18","_col19","_col20","_col27","_col28","_col30","_col31","_col32","_col37"] + <-Reducer 13 [SIMPLE_EDGE] + SHUFFLE [RS_41] + PartitionCols:_col9, _col14 + Select Operator [SEL_33] (rows=2086007 width=307) + Output:["_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col14","_col15","_col16","_col18","_col19","_col20","_col25"] + Merge Join Operator [MERGEJOIN_202] (rows=2086007 width=307) + Conds:RS_30._col4=RS_229._col0(Inner),Output:["_col0","_col5","_col6","_col7","_col9","_col10","_col11","_col18","_col19","_col20","_col21","_col22","_col23","_col25"] + <-Map 16 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_229] + PartitionCols:_col0 + Select Operator [SEL_228] (rows=72 width=101) + Output:["_col0","_col1"] + Filter Operator [FIL_227] (rows=72 width=101) + predicate:r_reason_sk is not null + TableScan [TS_18] (rows=72 width=101) + default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] + <-Reducer 12 [SIMPLE_EDGE] + SHUFFLE [RS_30] + PartitionCols:_col4 + Merge Join Operator [MERGEJOIN_201] (rows=2086007 width=213) + Conds:RS_27._col1, _col13, _col14=RS_225._col0, _col1, _col2(Inner),Output:["_col0","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col18","_col19","_col20","_col21","_col22","_col23"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_225] + PartitionCols:_col0, _col1, _col2 + Select Operator [SEL_223] (rows=265971 width=207) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Filter Operator [FIL_222] (rows=265971 width=183) + predicate:((cd_marital_status) IN ('M', 'D', 'U') and (cd_education_status) IN ('4 yr Degree', 'Primary', 'Advanced Degree') and cd_demo_sk is not null) + TableScan [TS_15] (rows=1861800 width=183) + default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status","cd_education_status"] + <-Reducer 11 [SIMPLE_EDGE] + SHUFFLE [RS_27] + PartitionCols:_col1, _col13, _col14 + Merge Join Operator [MERGEJOIN_200] (rows=2086007 width=371) + Conds:RS_24._col3=RS_226._col0(Inner),Output:["_col0","_col1","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col13","_col14"] + <-Map 15 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_226] + PartitionCols:_col0 + Select Operator [SEL_224] (rows=265971 width=183) + Output:["_col0","_col1","_col2"] + Please refer to the previous Filter Operator [FIL_222] + <-Reducer 10 [SIMPLE_EDGE] + SHUFFLE [RS_24] + PartitionCols:_col3 + Merge Join Operator [MERGEJOIN_199] (rows=11975292 width=245) + Conds:RS_218._col2=RS_221._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11"] + <-Map 14 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_221] + PartitionCols:_col0 + Select Operator [SEL_220] (rows=3529412 width=16) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_219] (rows=3529412 width=187) + predicate:((ca_state) IN ('KY', 'GA', 'NM', 'MT', 'OR', 'IN', 'WI', 'MO', 'WV') and (ca_country = 'United States') and ca_address_sk is not null) + TableScan [TS_9] (rows=40000000 width=187) + default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_country"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_218] + PartitionCols:_col2 + Select Operator [SEL_217] (rows=11975292 width=237) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] + Filter Operator [FIL_216] (rows=11975292 width=237) + predicate:(wr_refunded_addr_sk is not null and wr_returning_cdemo_sk is not null and wr_refunded_cdemo_sk is not null and wr_reason_sk is not null and wr_item_sk is not null and wr_order_number is not null) + TableScan [TS_6] (rows=14398467 width=237) + default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_refunded_cdemo_sk","wr_refunded_addr_sk","wr_returning_cdemo_sk","wr_reason_sk","wr_order_number","wr_fee","wr_refunded_cash"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_40] + PartitionCols:_col1, _col3 + Merge Join Operator [MERGEJOIN_198] (rows=143931136 width=39) + Conds:RS_215._col0=RS_207._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_207] PartitionCols:_col0 - Select Operator [SEL_227] (rows=72 width=101) - Output:["_col0","_col1"] - Filter Operator [FIL_226] (rows=72 width=101) - predicate:r_reason_sk is not null - TableScan [TS_18] (rows=72 width=101) - default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] - <-Reducer 12 [SIMPLE_EDGE] - SHUFFLE [RS_30] - PartitionCols:_col4 - Merge Join Operator [MERGEJOIN_200] (rows=2086007 width=213) - Conds:RS_27._col1, _col13, _col14=RS_224._col0, _col1, _col2(Inner),Output:["_col0","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col18","_col19","_col20","_col21","_col22","_col23"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_224] - PartitionCols:_col0, _col1, _col2 - Select Operator [SEL_222] (rows=265971 width=207) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_221] (rows=265971 width=183) - predicate:((cd_marital_status) IN ('M', 'D', 'U') and (cd_education_status) IN ('4 yr Degree', 'Primary', 'Advanced Degree') and cd_demo_sk is not null) - TableScan [TS_15] (rows=1861800 width=183) - default@customer_demographics,cd1,Tbl:COMPLETE,Col:COMPLETE,Output:["cd_demo_sk","cd_marital_status","cd_education_status"] - <-Reducer 11 [SIMPLE_EDGE] - SHUFFLE [RS_27] - PartitionCols:_col1, _col13, _col14 - Merge Join Operator [MERGEJOIN_199] (rows=2086007 width=371) - Conds:RS_24._col3=RS_225._col0(Inner),Output:["_col0","_col1","_col4","_col5","_col6","_col7","_col9","_col10","_col11","_col13","_col14"] - <-Map 15 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_225] - PartitionCols:_col0 - Select Operator [SEL_223] (rows=265971 width=183) - Output:["_col0","_col1","_col2"] - Please refer to the previous Filter Operator [FIL_221] - <-Reducer 10 [SIMPLE_EDGE] - SHUFFLE [RS_24] - PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_198] (rows=11975292 width=245) - Conds:RS_217._col2=RS_220._col0(Inner),Output:["_col0","_col1","_col3","_col4","_col5","_col6","_col7","_col9","_col10","_col11"] - <-Map 14 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_220] - PartitionCols:_col0 - Select Operator [SEL_219] (rows=3529412 width=16) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_218] (rows=3529412 width=187) - predicate:((ca_state) IN ('KY', 'GA', 'NM', 'MT', 'OR', 'IN', 'WI', 'MO', 'WV') and (ca_country = 'United States') and ca_address_sk is not null) - TableScan [TS_9] (rows=40000000 width=187) - default@customer_address,customer_address,Tbl:COMPLETE,Col:COMPLETE,Output:["ca_address_sk","ca_state","ca_country"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_217] - PartitionCols:_col2 - Select Operator [SEL_216] (rows=11975292 width=237) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] - Filter Operator [FIL_215] (rows=11975292 width=237) - predicate:(wr_refunded_addr_sk is not null and wr_returning_cdemo_sk is not null and wr_refunded_cdemo_sk is not null and wr_reason_sk is not null and wr_item_sk is not null and wr_order_number is not null) - TableScan [TS_6] (rows=14398467 width=237) - default@web_returns,web_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["wr_item_sk","wr_refunded_cdemo_sk","wr_refunded_addr_sk","wr_returning_cdemo_sk","wr_reason_sk","wr_order_number","wr_fee","wr_refunded_cash"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_40] - PartitionCols:_col1, _col3 - Merge Join Operator [MERGEJOIN_197] (rows=143931136 width=39) - Conds:RS_214._col0=RS_206._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_206] - PartitionCols:_col0 - Select Operator [SEL_205] (rows=652 width=4) - Output:["_col0"] - Filter Operator [FIL_204] (rows=652 width=8) - predicate:((d_year = 1998) and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_214] - PartitionCols:_col0 - Select Operator [SEL_213] (rows=143931136 width=43) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] - Filter Operator [FIL_212] (rows=143931136 width=243) - predicate:(((ws_sales_price >= 100) or (ws_sales_price <= 150) or (ws_sales_price >= 50) or (ws_sales_price <= 100) or (ws_sales_price >= 150) or (ws_sales_price <= 200)) and ((ws_net_profit >= 100) or (ws_net_profit <= 200) or (ws_net_profit >= 150) or (ws_net_profit <= 300) or (ws_net_profit >= 50) or (ws_net_profit <= 250)) and ws_sold_date_sk is not null and ws_web_page_sk is not null and ws_item_sk is not null and ws_order_number is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_38_date_dim_d_date_sk_min) AND DynamicValue(RS_38_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_38_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=243) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_order_number","ws_quantity","ws_sales_price","ws_net_profit"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_211] - Group By Operator [GBY_210] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_209] - Group By Operator [GBY_208] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_207] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_205] + Select Operator [SEL_206] (rows=652 width=4) + Output:["_col0"] + Filter Operator [FIL_205] (rows=652 width=8) + predicate:((d_year = 1998) and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_215] + PartitionCols:_col0 + Select Operator [SEL_214] (rows=143931136 width=43) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col9","_col10"] + Filter Operator [FIL_213] (rows=143931136 width=243) + predicate:(((ws_sales_price >= 100) or (ws_sales_price <= 150) or (ws_sales_price >= 50) or (ws_sales_price <= 100) or (ws_sales_price >= 150) or (ws_sales_price <= 200)) and ((ws_net_profit >= 100) or (ws_net_profit <= 200) or (ws_net_profit >= 150) or (ws_net_profit <= 300) or (ws_net_profit >= 50) or (ws_net_profit <= 250)) and ws_sold_date_sk is not null and ws_web_page_sk is not null and ws_item_sk is not null and ws_order_number is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_38_date_dim_d_date_sk_min) AND DynamicValue(RS_38_date_dim_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_38_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=243) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_web_page_sk","ws_order_number","ws_quantity","ws_sales_price","ws_net_profit"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_212] + Group By Operator [GBY_211] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_210] + Group By Operator [GBY_209] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_208] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_206] diff --git ql/src/test/results/clientpositive/perf/tez/query86.q.out ql/src/test/results/clientpositive/perf/tez/query86.q.out index 37414f697f..16e6577ffb 100644 --- ql/src/test/results/clientpositive/perf/tez/query86.q.out +++ ql/src/test/results/clientpositive/perf/tez/query86.q.out @@ -72,76 +72,78 @@ Stage-0 limit:-1 Stage-1 Reducer 6 vectorized - File Output Operator [FS_84] - Limit [LIM_83] (rows=100 width=490) + File Output Operator [FS_86] + Limit [LIM_85] (rows=100 width=490) Number of rows:100 - Select Operator [SEL_82] (rows=3060 width=490) + Select Operator [SEL_84] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4"] <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_81] - Select Operator [SEL_80] (rows=3060 width=490) + SHUFFLE [RS_83] + Select Operator [SEL_82] (rows=3060 width=490) Output:["_col0","_col1","_col2","_col3","_col4","_col5"] - PTF Operator [PTF_79] (rows=3060 width=302) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] - Select Operator [SEL_78] (rows=3060 width=302) - Output:["_col0","_col1","_col2","_col3"] - <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_77] - PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END - Select Operator [SEL_76] (rows=3060 width=302) - Output:["_col0","_col1","_col2","_col3"] - Group By Operator [GBY_75] (rows=3060 width=302) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col0, _col1, _col2 - Group By Operator [GBY_17] (rows=507960 width=302) - Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L - Select Operator [SEL_15] (rows=143966864 width=293) - Output:["_col0","_col1","_col2"] - Merge Join Operator [MERGEJOIN_60] (rows=143966864 width=293) - Conds:RS_12._col1=RS_74._col0(Inner),Output:["_col2","_col5","_col6"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_74] - PartitionCols:_col0 - Select Operator [SEL_73] (rows=462000 width=186) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_72] (rows=462000 width=186) - predicate:i_item_sk is not null - TableScan [TS_6] (rows=462000 width=186) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_59] (rows=143966864 width=115) - Conds:RS_71._col0=RS_63._col0(Inner),Output:["_col1","_col2"] - <-Map 7 [SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_63] - PartitionCols:_col0 - Select Operator [SEL_62] (rows=317 width=4) - Output:["_col0"] - Filter Operator [FIL_61] (rows=317 width=8) - predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) - TableScan [TS_3] (rows=73049 width=8) - default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_71] - PartitionCols:_col0 - Select Operator [SEL_70] (rows=143966864 width=119) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_69] (rows=143966864 width=119) - predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_d1_d_date_sk_min) AND DynamicValue(RS_10_d1_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_d1_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=144002668 width=119) - default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_net_paid"] - <-Reducer 8 [BROADCAST_EDGE] vectorized - BROADCAST [RS_68] - Group By Operator [GBY_67] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized - PARTITION_ONLY_SHUFFLE [RS_66] - Group By Operator [GBY_65] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_64] (rows=317 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_62] + Top N Key Operator [TNK_81] (rows=3060 width=302) + keys:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN (((grouping(_col3, 1L) + grouping(_col3, 0L)) = 0L)) THEN (_col0) ELSE (null) END, rank_window_0,top n:100 + PTF Operator [PTF_80] (rows=3060 width=302) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 DESC NULLS LAST","partition by:":"(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END"}] + Select Operator [SEL_79] (rows=3060 width=302) + Output:["_col0","_col1","_col2","_col3"] + <-Reducer 4 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_78] + PartitionCols:(grouping(_col3, 1L) + grouping(_col3, 0L)), CASE WHEN ((grouping(_col3, 0L) = UDFToLong(0))) THEN (_col0) ELSE (CAST( null AS STRING)) END + Select Operator [SEL_77] (rows=3060 width=302) + Output:["_col0","_col1","_col2","_col3"] + Group By Operator [GBY_76] (rows=3060 width=302) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0, _col1, _col2 + Group By Operator [GBY_17] (rows=507960 width=302) + Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(_col2)"],keys:_col0, _col1, 0L + Select Operator [SEL_15] (rows=143966864 width=293) + Output:["_col0","_col1","_col2"] + Merge Join Operator [MERGEJOIN_61] (rows=143966864 width=293) + Conds:RS_12._col1=RS_75._col0(Inner),Output:["_col2","_col5","_col6"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_75] + PartitionCols:_col0 + Select Operator [SEL_74] (rows=462000 width=186) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_73] (rows=462000 width=186) + predicate:i_item_sk is not null + TableScan [TS_6] (rows=462000 width=186) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_class","i_category"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col1 + Merge Join Operator [MERGEJOIN_60] (rows=143966864 width=115) + Conds:RS_72._col0=RS_64._col0(Inner),Output:["_col1","_col2"] + <-Map 7 [SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_64] + PartitionCols:_col0 + Select Operator [SEL_63] (rows=317 width=4) + Output:["_col0"] + Filter Operator [FIL_62] (rows=317 width=8) + predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) + TableScan [TS_3] (rows=73049 width=8) + default@date_dim,d1,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_72] + PartitionCols:_col0 + Select Operator [SEL_71] (rows=143966864 width=119) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_70] (rows=143966864 width=119) + predicate:(ws_sold_date_sk is not null and ws_item_sk is not null and ws_sold_date_sk BETWEEN DynamicValue(RS_10_d1_d_date_sk_min) AND DynamicValue(RS_10_d1_d_date_sk_max) and in_bloom_filter(ws_sold_date_sk, DynamicValue(RS_10_d1_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=144002668 width=119) + default@web_sales,web_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ws_sold_date_sk","ws_item_sk","ws_net_paid"] + <-Reducer 8 [BROADCAST_EDGE] vectorized + BROADCAST [RS_69] + Group By Operator [GBY_68] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 7 [CUSTOM_SIMPLE_EDGE] vectorized + PARTITION_ONLY_SHUFFLE [RS_67] + Group By Operator [GBY_66] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_65] (rows=317 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_63] diff --git ql/src/test/results/clientpositive/perf/tez/query89.q.out ql/src/test/results/clientpositive/perf/tez/query89.q.out index 927da252da..97cc6c23e3 100644 --- ql/src/test/results/clientpositive/perf/tez/query89.q.out +++ ql/src/test/results/clientpositive/perf/tez/query89.q.out @@ -79,90 +79,92 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_112] - Limit [LIM_111] (rows=100 width=801) + File Output Operator [FS_114] + Limit [LIM_113] (rows=100 width=801) Number of rows:100 - Select Operator [SEL_110] (rows=181038 width=801) + Select Operator [SEL_112] (rows=181038 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_109] - Select Operator [SEL_108] (rows=181038 width=801) + SHUFFLE [RS_111] + Select Operator [SEL_110] (rows=181038 width=801) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_107] (rows=181038 width=689) - predicate:CASE WHEN ((avg_window_0 <> 0)) THEN (((abs((_col6 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END - Select Operator [SEL_106] (rows=362076 width=577) - Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - PTF Operator [PTF_105] (rows=362076 width=577) - Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS FIRST","partition by:":"_col2, _col0, _col4, _col5"}] - Select Operator [SEL_104] (rows=362076 width=577) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] - <-Reducer 5 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_103] - PartitionCols:_col2, _col0, _col4, _col5 - Group By Operator [GBY_102] (rows=362076 width=577) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 - <-Reducer 4 [SIMPLE_EDGE] - SHUFFLE [RS_23] - PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 - Group By Operator [GBY_22] (rows=76480702 width=577) - Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col7, _col9, _col11, _col12 - Merge Join Operator [MERGEJOIN_84] (rows=76480702 width=542) - Conds:RS_18._col2=RS_101._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12"] - <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_101] - PartitionCols:_col0 - Select Operator [SEL_100] (rows=1704 width=183) - Output:["_col0","_col1","_col2"] - Filter Operator [FIL_99] (rows=1704 width=183) - predicate:s_store_sk is not null - TableScan [TS_9] (rows=1704 width=183) - default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_83] (rows=76480702 width=366) - Conds:RS_15._col0=RS_87._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col7","_col9"] - <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_87] - PartitionCols:_col0 - Select Operator [SEL_86] (rows=652 width=8) - Output:["_col0","_col1"] - Filter Operator [FIL_85] (rows=652 width=12) - predicate:((d_year = 2000) and d_date_sk is not null) - TableScan [TS_6] (rows=73049 width=12) - default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_15] - PartitionCols:_col0 - Merge Join Operator [MERGEJOIN_82] (rows=76480702 width=364) - Conds:RS_95._col1=RS_98._col0(Inner),Output:["_col0","_col2","_col3","_col5","_col6","_col7"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_95] - PartitionCols:_col1 - Select Operator [SEL_94] (rows=525329897 width=118) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_93] (rows=525329897 width=118) - predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) - TableScan [TS_0] (rows=575995635 width=118) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] - <-Reducer 10 [BROADCAST_EDGE] vectorized - BROADCAST [RS_92] - Group By Operator [GBY_91] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] - <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_90] - Group By Operator [GBY_89] (rows=1 width=12) - Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_88] (rows=652 width=4) - Output:["_col0"] - Please refer to the previous Select Operator [SEL_86] - <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_98] - PartitionCols:_col0 - Select Operator [SEL_97] (rows=6988 width=286) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_96] (rows=6988 width=286) - predicate:((i_class) IN ('wallpaper', 'parenting', 'musical', 'womens', 'birdal', 'pants') and (i_category) IN ('Home', 'Books', 'Electronics', 'Shoes', 'Jewelry', 'Men') and (((i_category) IN ('Home', 'Books', 'Electronics') and (i_class) IN ('wallpaper', 'parenting', 'musical')) or ((i_category) IN ('Shoes', 'Jewelry', 'Men') and (i_class) IN ('womens', 'birdal', 'pants'))) and i_item_sk is not null) - TableScan [TS_3] (rows=462000 width=286) - default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category"] + Top N Key Operator [TNK_109] (rows=181038 width=689) + keys:(_col6 - avg_window_0), _col4,top n:100 + Filter Operator [FIL_108] (rows=181038 width=689) + predicate:CASE WHEN ((avg_window_0 <> 0)) THEN (((abs((_col6 - avg_window_0)) / avg_window_0) > 0.1)) ELSE (false) END + Select Operator [SEL_107] (rows=362076 width=577) + Output:["avg_window_0","_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + PTF Operator [PTF_106] (rows=362076 width=577) + Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col2 ASC NULLS FIRST, _col0 ASC NULLS FIRST, _col4 ASC NULLS FIRST, _col5 ASC NULLS FIRST","partition by:":"_col2, _col0, _col4, _col5"}] + Select Operator [SEL_105] (rows=362076 width=577) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"] + <-Reducer 5 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_104] + PartitionCols:_col2, _col0, _col4, _col5 + Group By Operator [GBY_103] (rows=362076 width=577) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0, KEY._col1, KEY._col2, KEY._col3, KEY._col4, KEY._col5 + <-Reducer 4 [SIMPLE_EDGE] + SHUFFLE [RS_23] + PartitionCols:_col0, _col1, _col2, _col3, _col4, _col5 + Group By Operator [GBY_22] (rows=76480702 width=577) + Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6"],aggregations:["sum(_col3)"],keys:_col5, _col6, _col7, _col9, _col11, _col12 + Merge Join Operator [MERGEJOIN_85] (rows=76480702 width=542) + Conds:RS_18._col2=RS_102._col0(Inner),Output:["_col3","_col5","_col6","_col7","_col9","_col11","_col12"] + <-Map 11 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_102] + PartitionCols:_col0 + Select Operator [SEL_101] (rows=1704 width=183) + Output:["_col0","_col1","_col2"] + Filter Operator [FIL_100] (rows=1704 width=183) + predicate:s_store_sk is not null + TableScan [TS_9] (rows=1704 width=183) + default@store,store,Tbl:COMPLETE,Col:COMPLETE,Output:["s_store_sk","s_store_name","s_company_name"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col2 + Merge Join Operator [MERGEJOIN_84] (rows=76480702 width=366) + Conds:RS_15._col0=RS_88._col0(Inner),Output:["_col2","_col3","_col5","_col6","_col7","_col9"] + <-Map 9 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_88] + PartitionCols:_col0 + Select Operator [SEL_87] (rows=652 width=8) + Output:["_col0","_col1"] + Filter Operator [FIL_86] (rows=652 width=12) + predicate:((d_year = 2000) and d_date_sk is not null) + TableScan [TS_6] (rows=73049 width=12) + default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_year","d_moy"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_15] + PartitionCols:_col0 + Merge Join Operator [MERGEJOIN_83] (rows=76480702 width=364) + Conds:RS_96._col1=RS_99._col0(Inner),Output:["_col0","_col2","_col3","_col5","_col6","_col7"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_96] + PartitionCols:_col1 + Select Operator [SEL_95] (rows=525329897 width=118) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_94] (rows=525329897 width=118) + predicate:(ss_sold_date_sk is not null and ss_store_sk is not null and ss_item_sk is not null and ss_sold_date_sk BETWEEN DynamicValue(RS_16_date_dim_d_date_sk_min) AND DynamicValue(RS_16_date_dim_d_date_sk_max) and in_bloom_filter(ss_sold_date_sk, DynamicValue(RS_16_date_dim_d_date_sk_bloom_filter))) + TableScan [TS_0] (rows=575995635 width=118) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_sold_date_sk","ss_item_sk","ss_store_sk","ss_sales_price"] + <-Reducer 10 [BROADCAST_EDGE] vectorized + BROADCAST [RS_93] + Group By Operator [GBY_92] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] + <-Map 9 [CUSTOM_SIMPLE_EDGE] vectorized + SHUFFLE [RS_91] + Group By Operator [GBY_90] (rows=1 width=12) + Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] + Select Operator [SEL_89] (rows=652 width=4) + Output:["_col0"] + Please refer to the previous Select Operator [SEL_87] + <-Map 8 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_99] + PartitionCols:_col0 + Select Operator [SEL_98] (rows=6988 width=286) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_97] (rows=6988 width=286) + predicate:((i_class) IN ('wallpaper', 'parenting', 'musical', 'womens', 'birdal', 'pants') and (i_category) IN ('Home', 'Books', 'Electronics', 'Shoes', 'Jewelry', 'Men') and (((i_category) IN ('Home', 'Books', 'Electronics') and (i_class) IN ('wallpaper', 'parenting', 'musical')) or ((i_category) IN ('Shoes', 'Jewelry', 'Men') and (i_class) IN ('womens', 'birdal', 'pants'))) and i_item_sk is not null) + TableScan [TS_3] (rows=462000 width=286) + default@item,item,Tbl:COMPLETE,Col:COMPLETE,Output:["i_item_sk","i_brand","i_class","i_category"] diff --git ql/src/test/results/clientpositive/perf/tez/query93.q.out ql/src/test/results/clientpositive/perf/tez/query93.q.out index 0df41d120b..d0bde224fb 100644 --- ql/src/test/results/clientpositive/perf/tez/query93.q.out +++ ql/src/test/results/clientpositive/perf/tez/query93.q.out @@ -53,54 +53,56 @@ Stage-0 limit:100 Stage-1 Reducer 5 vectorized - File Output Operator [FS_78] - Limit [LIM_77] (rows=100 width=115) + File Output Operator [FS_80] + Limit [LIM_79] (rows=100 width=115) Number of rows:100 - Select Operator [SEL_76] (rows=1398474 width=115) + Select Operator [SEL_78] (rows=1398474 width=115) Output:["_col0","_col1"] <-Reducer 4 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_75] - Group By Operator [GBY_74] (rows=1398474 width=115) - Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 - <-Reducer 3 [SIMPLE_EDGE] - SHUFFLE [RS_18] - PartitionCols:_col0 - Group By Operator [GBY_17] (rows=569016747 width=115) - Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 - Select Operator [SEL_15] (rows=569016747 width=118) - Output:["_col0","_col1"] - Merge Join Operator [MERGEJOIN_64] (rows=569016747 width=118) - Conds:RS_12._col0, _col2=RS_73._col0, _col2(Inner),Output:["_col3","_col6","_col8","_col9"] - <-Map 7 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_73] - PartitionCols:_col0, _col2 - Select Operator [SEL_72] (rows=575995635 width=122) - Output:["_col0","_col1","_col2","_col3","_col4"] - Filter Operator [FIL_71] (rows=575995635 width=122) - predicate:(ss_item_sk is not null and ss_ticket_number is not null) - TableScan [TS_6] (rows=575995635 width=122) - default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_sales_price"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_12] - PartitionCols:_col0, _col2 - Merge Join Operator [MERGEJOIN_63] (rows=55574563 width=11) - Conds:RS_67._col1=RS_70._col0(Inner),Output:["_col0","_col2","_col3"] - <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_67] - PartitionCols:_col1 - Select Operator [SEL_66] (rows=55574563 width=15) - Output:["_col0","_col1","_col2","_col3"] - Filter Operator [FIL_65] (rows=55574563 width=15) - predicate:(sr_reason_sk is not null and sr_item_sk is not null and sr_ticket_number is not null) - TableScan [TS_0] (rows=57591150 width=15) - default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_reason_sk","sr_ticket_number","sr_return_quantity"] - <-Map 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_70] - PartitionCols:_col0 - Select Operator [SEL_69] (rows=1 width=4) - Output:["_col0"] - Filter Operator [FIL_68] (rows=1 width=101) - predicate:((r_reason_desc = 'Did not like the warranty') and r_reason_sk is not null) - TableScan [TS_3] (rows=72 width=101) - default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] + SHUFFLE [RS_77] + Top N Key Operator [TNK_76] (rows=1398474 width=115) + keys:_col1, _col0,top n:100 + Group By Operator [GBY_75] (rows=1398474 width=115) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_18] + PartitionCols:_col0 + Group By Operator [GBY_17] (rows=569016747 width=115) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Select Operator [SEL_15] (rows=569016747 width=118) + Output:["_col0","_col1"] + Merge Join Operator [MERGEJOIN_65] (rows=569016747 width=118) + Conds:RS_12._col0, _col2=RS_74._col0, _col2(Inner),Output:["_col3","_col6","_col8","_col9"] + <-Map 7 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_74] + PartitionCols:_col0, _col2 + Select Operator [SEL_73] (rows=575995635 width=122) + Output:["_col0","_col1","_col2","_col3","_col4"] + Filter Operator [FIL_72] (rows=575995635 width=122) + predicate:(ss_item_sk is not null and ss_ticket_number is not null) + TableScan [TS_6] (rows=575995635 width=122) + default@store_sales,store_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["ss_item_sk","ss_customer_sk","ss_ticket_number","ss_quantity","ss_sales_price"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_12] + PartitionCols:_col0, _col2 + Merge Join Operator [MERGEJOIN_64] (rows=55574563 width=11) + Conds:RS_68._col1=RS_71._col0(Inner),Output:["_col0","_col2","_col3"] + <-Map 1 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_68] + PartitionCols:_col1 + Select Operator [SEL_67] (rows=55574563 width=15) + Output:["_col0","_col1","_col2","_col3"] + Filter Operator [FIL_66] (rows=55574563 width=15) + predicate:(sr_reason_sk is not null and sr_item_sk is not null and sr_ticket_number is not null) + TableScan [TS_0] (rows=57591150 width=15) + default@store_returns,store_returns,Tbl:COMPLETE,Col:COMPLETE,Output:["sr_item_sk","sr_reason_sk","sr_ticket_number","sr_return_quantity"] + <-Map 6 [SIMPLE_EDGE] vectorized + SHUFFLE [RS_71] + PartitionCols:_col0 + Select Operator [SEL_70] (rows=1 width=4) + Output:["_col0"] + Filter Operator [FIL_69] (rows=1 width=101) + predicate:((r_reason_desc = 'Did not like the warranty') and r_reason_sk is not null) + TableScan [TS_3] (rows=72 width=101) + default@reason,reason,Tbl:COMPLETE,Col:COMPLETE,Output:["r_reason_sk","r_reason_desc"] diff --git ql/src/test/results/clientpositive/perf/tez/query99.q.out ql/src/test/results/clientpositive/perf/tez/query99.q.out index c01122f435..d24d5ccc60 100644 --- ql/src/test/results/clientpositive/perf/tez/query99.q.out +++ ql/src/test/results/clientpositive/perf/tez/query99.q.out @@ -95,94 +95,94 @@ Stage-0 limit:-1 Stage-1 Reducer 7 vectorized - File Output Operator [FS_126] - Limit [LIM_125] (rows=100 width=590) + File Output Operator [FS_131] + Limit [LIM_130] (rows=100 width=590) Number of rows:100 - Select Operator [SEL_124] (rows=3920468 width=590) + Select Operator [SEL_129] (rows=3920468 width=590) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"] <-Reducer 6 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_123] - Select Operator [SEL_122] (rows=3920468 width=590) + SHUFFLE [RS_128] + Select Operator [SEL_127] (rows=3920468 width=590) Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Group By Operator [GBY_121] (rows=3920468 width=406) + Group By Operator [GBY_126] (rows=3920468 width=406) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(VALUE._col0)","sum(VALUE._col1)","sum(VALUE._col2)","sum(VALUE._col3)","sum(VALUE._col4)"],keys:KEY._col0, KEY._col1, KEY._col2 <-Reducer 5 [SIMPLE_EDGE] SHUFFLE [RS_29] PartitionCols:_col0, _col1, _col2 Group By Operator [GBY_28] (rows=7840936 width=406) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7"],aggregations:["sum(_col4)","sum(_col5)","sum(_col6)","sum(_col7)","sum(_col8)"],keys:_col13, _col15, _col11 - Top N Key Operator [TNK_56] (rows=15681873 width=386) + Top N Key Operator [TNK_59] (rows=15681873 width=386) keys:_col13, _col15, _col11,top n:100 - Merge Join Operator [MERGEJOIN_100] (rows=15681873 width=386) - Conds:RS_24._col2=RS_103._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col8","_col11","_col13","_col15"] + Merge Join Operator [MERGEJOIN_105] (rows=15681873 width=386) + Conds:RS_24._col2=RS_108._col0(Inner),Output:["_col4","_col5","_col6","_col7","_col8","_col11","_col13","_col15"] <-Map 11 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_103] + SHUFFLE [RS_108] PartitionCols:_col0 - Select Operator [SEL_102] (rows=1 width=88) + Select Operator [SEL_107] (rows=1 width=88) Output:["_col0","_col1"] - Filter Operator [FIL_101] (rows=1 width=88) + Filter Operator [FIL_106] (rows=1 width=88) predicate:sm_ship_mode_sk is not null TableScan [TS_12] (rows=1 width=88) default@ship_mode,ship_mode,Tbl:COMPLETE,Col:COMPLETE,Output:["sm_ship_mode_sk","sm_type"] <-Reducer 4 [SIMPLE_EDGE] SHUFFLE [RS_24] PartitionCols:_col2 - Merge Join Operator [MERGEJOIN_99] (rows=282273729 width=305) - Conds:RS_21._col3=RS_120._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col11","_col13"] + Merge Join Operator [MERGEJOIN_104] (rows=282273729 width=305) + Conds:RS_21._col3=RS_125._col0(Inner),Output:["_col2","_col4","_col5","_col6","_col7","_col8","_col11","_col13"] <-Map 10 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_120] + SHUFFLE [RS_125] PartitionCols:_col0 - Select Operator [SEL_119] (rows=27 width=188) + Select Operator [SEL_124] (rows=27 width=188) Output:["_col0","_col1"] - Filter Operator [FIL_118] (rows=27 width=104) + Filter Operator [FIL_123] (rows=27 width=104) predicate:w_warehouse_sk is not null TableScan [TS_9] (rows=27 width=104) default@warehouse,warehouse,Tbl:COMPLETE,Col:COMPLETE,Output:["w_warehouse_sk","w_warehouse_name"] <-Reducer 3 [SIMPLE_EDGE] SHUFFLE [RS_21] PartitionCols:_col3 - Merge Join Operator [MERGEJOIN_98] (rows=282273729 width=125) - Conds:RS_18._col1=RS_117._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] + Merge Join Operator [MERGEJOIN_103] (rows=282273729 width=125) + Conds:RS_18._col1=RS_122._col0(Inner),Output:["_col2","_col3","_col4","_col5","_col6","_col7","_col8","_col11"] <-Map 9 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_117] + SHUFFLE [RS_122] PartitionCols:_col0 - Select Operator [SEL_116] (rows=60 width=102) + Select Operator [SEL_121] (rows=60 width=102) Output:["_col0","_col1"] - Filter Operator [FIL_115] (rows=60 width=102) + Filter Operator [FIL_120] (rows=60 width=102) predicate:cc_call_center_sk is not null TableScan [TS_6] (rows=60 width=102) default@call_center,call_center,Tbl:COMPLETE,Col:COMPLETE,Output:["cc_call_center_sk","cc_name"] <-Reducer 2 [SIMPLE_EDGE] SHUFFLE [RS_18] PartitionCols:_col1 - Merge Join Operator [MERGEJOIN_97] (rows=282273729 width=31) - Conds:RS_111._col0=RS_114._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] + Merge Join Operator [MERGEJOIN_102] (rows=282273729 width=31) + Conds:RS_116._col0=RS_119._col0(Inner),Output:["_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_111] + SHUFFLE [RS_116] PartitionCols:_col0 - Select Operator [SEL_110] (rows=282273729 width=35) + Select Operator [SEL_115] (rows=282273729 width=35) Output:["_col0","_col1","_col2","_col3","_col4","_col5","_col6","_col7","_col8"] - Filter Operator [FIL_109] (rows=282273729 width=19) + Filter Operator [FIL_114] (rows=282273729 width=19) predicate:(cs_warehouse_sk is not null and cs_ship_date_sk is not null and cs_ship_mode_sk is not null and cs_call_center_sk is not null and cs_ship_mode_sk BETWEEN DynamicValue(RS_25_ship_mode_sm_ship_mode_sk_min) AND DynamicValue(RS_25_ship_mode_sm_ship_mode_sk_max) and in_bloom_filter(cs_ship_mode_sk, DynamicValue(RS_25_ship_mode_sm_ship_mode_sk_bloom_filter))) TableScan [TS_0] (rows=287989836 width=19) default@catalog_sales,catalog_sales,Tbl:COMPLETE,Col:COMPLETE,Output:["cs_sold_date_sk","cs_ship_date_sk","cs_call_center_sk","cs_ship_mode_sk","cs_warehouse_sk"] <-Reducer 12 [BROADCAST_EDGE] vectorized - BROADCAST [RS_108] - Group By Operator [GBY_107] (rows=1 width=12) + BROADCAST [RS_113] + Group By Operator [GBY_112] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(VALUE._col0)","max(VALUE._col1)","bloom_filter(VALUE._col2, expectedEntries=1000000)"] <-Map 11 [CUSTOM_SIMPLE_EDGE] vectorized - SHUFFLE [RS_106] - Group By Operator [GBY_105] (rows=1 width=12) + SHUFFLE [RS_111] + Group By Operator [GBY_110] (rows=1 width=12) Output:["_col0","_col1","_col2"],aggregations:["min(_col0)","max(_col0)","bloom_filter(_col0, expectedEntries=1000000)"] - Select Operator [SEL_104] (rows=1 width=4) + Select Operator [SEL_109] (rows=1 width=4) Output:["_col0"] - Please refer to the previous Select Operator [SEL_102] + Please refer to the previous Select Operator [SEL_107] <-Map 8 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_114] + SHUFFLE [RS_119] PartitionCols:_col0 - Select Operator [SEL_113] (rows=317 width=4) + Select Operator [SEL_118] (rows=317 width=4) Output:["_col0"] - Filter Operator [FIL_112] (rows=317 width=8) + Filter Operator [FIL_117] (rows=317 width=8) predicate:(d_month_seq BETWEEN 1212 AND 1223 and d_date_sk is not null) TableScan [TS_3] (rows=73049 width=8) default@date_dim,date_dim,Tbl:COMPLETE,Col:COMPLETE,Output:["d_date_sk","d_month_seq"] diff --git ql/src/test/results/clientpositive/tez/explainanalyze_3.q.out ql/src/test/results/clientpositive/tez/explainanalyze_3.q.out index 7d303849d5..981fa86d25 100644 --- ql/src/test/results/clientpositive/tez/explainanalyze_3.q.out +++ ql/src/test/results/clientpositive/tez/explainanalyze_3.q.out @@ -704,17 +704,19 @@ Stage-0 limit:5 Stage-1 Reducer 2 vectorized - File Output Operator [FS_10] - Limit [LIM_9] (rows=5/5 width=178) + File Output Operator [FS_12] + Limit [LIM_11] (rows=5/5 width=178) Number of rows:5 - Select Operator [SEL_8] (rows=500/5 width=178) + Select Operator [SEL_10] (rows=500/5 width=178) Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_7] - Select Operator [SEL_6] (rows=500/500 width=178) + SHUFFLE [RS_9] + Select Operator [SEL_8] (rows=500/36 width=178) Output:["_col0","_col1"] - TableScan [TS_0] (rows=500/500 width=178) - default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] + Top N Key Operator [TNK_7] (rows=500/36 width=178) + keys:key,top n:5 + TableScan [TS_0] (rows=500/500 width=178) + default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] PREHOOK: query: create table orc_merge5_n1 (userid bigint, string1 string, subtype double, decimal1 decimal(38,0), ts timestamp) stored as orc PREHOOK: type: CREATETABLE diff --git ql/src/test/results/clientpositive/tez/explainuser_3.q.out ql/src/test/results/clientpositive/tez/explainuser_3.q.out index 2377a6674e..d4374f02e3 100644 --- ql/src/test/results/clientpositive/tez/explainuser_3.q.out +++ ql/src/test/results/clientpositive/tez/explainuser_3.q.out @@ -560,17 +560,19 @@ Stage-0 limit:5 Stage-1 Reducer 2 vectorized - File Output Operator [FS_10] - Limit [LIM_9] (rows=5 width=178) + File Output Operator [FS_12] + Limit [LIM_11] (rows=5 width=178) Number of rows:5 - Select Operator [SEL_8] (rows=500 width=178) + Select Operator [SEL_10] (rows=500 width=178) Output:["_col0","_col1"] <-Map 1 [SIMPLE_EDGE] vectorized - SHUFFLE [RS_7] - Select Operator [SEL_6] (rows=500 width=178) + SHUFFLE [RS_9] + Select Operator [SEL_8] (rows=500 width=178) Output:["_col0","_col1"] - TableScan [TS_0] (rows=500 width=178) - default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] + Top N Key Operator [TNK_7] (rows=500 width=178) + keys:key,top n:5 + TableScan [TS_0] (rows=500 width=178) + default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] PREHOOK: query: create table orc_merge5_n0 (userid bigint, string1 string, subtype double, decimal1 decimal, ts timestamp) stored as orc PREHOOK: type: CREATETABLE diff --git ql/src/test/results/clientpositive/tez/topnkey.q.out ql/src/test/results/clientpositive/tez/topnkey.q.out index cf2ecf7133..ba4abe0870 100644 --- ql/src/test/results/clientpositive/tez/topnkey.q.out +++ ql/src/test/results/clientpositive/tez/topnkey.q.out @@ -1,178 +1,58 @@ -PREHOOK: query: EXPLAIN EXTENDED +PREHOOK: query: EXPLAIN SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src PREHOOK: Output: hdfs://### HDFS PATH ### -POSTHOOK: query: EXPLAIN EXTENDED +POSTHOOK: query: EXPLAIN SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: hdfs://### HDFS PATH ### -OPTIMIZED SQL: SELECT `key` AS `$f0`, SUM(CAST(SUBSTR(`value`, 5) AS INTEGER)) AS `$f1` -FROM `default`.`src` -GROUP BY `key` -ORDER BY `key` -LIMIT 5 -STAGE DEPENDENCIES: - Stage-1 is a root stage - Stage-0 depends on stages: Stage-1 +Plan optimized by CBO. -STAGE PLANS: - Stage: Stage-1 - Tez -#### A masked pattern was here #### - Edges: - Reducer 2 <- Map 1 (SIMPLE_EDGE) - Reducer 3 <- Reducer 2 (SIMPLE_EDGE) -#### A masked pattern was here #### - Vertices: - Map 1 - Map Operator Tree: - TableScan - alias: src - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - GatherStats: false - Select Operator - expressions: key (type: string), UDFToInteger(substr(value, 5)) (type: int) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: _col0 (type: string) - null sort order: z - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - top n: 5 - Group By Operator - aggregations: sum(_col1) - keys: _col0 (type: string) - minReductionHashAggr: 0.5 - mode: hash - outputColumnNames: _col0, _col1 - Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: bigint) - auto parallelism: true - Path -> Alias: - hdfs://### HDFS PATH ### [src] - Path -> Partition: - hdfs://### HDFS PATH ### - Partition - base file name: src - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - bucketing_version 2 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - location hdfs://### HDFS PATH ### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - bucketing_version 2 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - location hdfs://### HDFS PATH ### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.src - name: default.src - Truncated Path -> Alias: - /src [src] - Reducer 2 - Needs Tagging: false - Reduce Operator Tree: - Group By Operator - aggregations: sum(VALUE._col0) - keys: KEY._col0 (type: string) - mode: mergepartial - outputColumnNames: _col0, _col1 - Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + - Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: bigint) - auto parallelism: false - Reducer 3 - Needs Tagging: false - Reduce Operator Tree: - Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: bigint) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - Limit - Number of rows: 5 - Statistics: Num rows: 5 Data size: 475 Basic stats: COMPLETE Column stats: COMPLETE - File Output Operator - compressed: false - GlobalTableId: 0 - directory: hdfs://### HDFS PATH ### - NumFilesPerFileSink: 1 - Statistics: Num rows: 5 Data size: 475 Basic stats: COMPLETE Column stats: COMPLETE - Stats Publishing Key Prefix: hdfs://### HDFS PATH ### - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - columns _col0,_col1 - columns.types string:bigint - escape.delim \ - hive.serialization.extend.additional.nesting.levels true - serialization.escape.crlf true - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false +Vertex dependency in root stage +Reducer 2 <- Map 1 (SIMPLE_EDGE) +Reducer 3 <- Reducer 2 (SIMPLE_EDGE) - Stage: Stage-0 - Fetch Operator - limit: 5 - Processor Tree: - ListSink +Stage-0 + Fetch Operator + limit:5 + Stage-1 + Reducer 3 + File Output Operator [FS_10] + Limit [LIM_9] (rows=5 width=95) + Number of rows:5 + Select Operator [SEL_8] (rows=250 width=95) + Output:["_col0","_col1"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_7] + Group By Operator [GBY_5] (rows=250 width=95) + Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)"],keys:KEY._col0 + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_4] + PartitionCols:_col0 + Group By Operator [GBY_3] (rows=250 width=95) + Output:["_col0","_col1"],aggregations:["sum(_col1)"],keys:_col0 + Select Operator [SEL_1] (rows=500 width=178) + Output:["_col0","_col1"] + Top N Key Operator [TNK_14] (rows=500 width=178) + keys:key,top n:5 + TableScan [TS_0] (rows=500 width=178) + default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] +PREHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: hdfs://### HDFS PATH ### +0 0 +10 10 +100 200 +103 206 +104 208 PREHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -187,180 +67,333 @@ POSTHOOK: Output: hdfs://### HDFS PATH ### 103 206 104 208 PREHOOK: query: EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src PREHOOK: Output: hdfs://### HDFS PATH ### POSTHOOK: query: EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: hdfs://### HDFS PATH ### Plan optimized by CBO. Vertex dependency in root stage -Reducer 2 <- Map 1 (SIMPLE_EDGE) +Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 5 (SIMPLE_EDGE) Reducer 3 <- Reducer 2 (SIMPLE_EDGE) +Reducer 4 <- Reducer 3 (SIMPLE_EDGE) Stage-0 Fetch Operator limit:5 Stage-1 - Reducer 3 - File Output Operator [FS_9] - Limit [LIM_8] (rows=5 width=87) + Reducer 4 + File Output Operator [FS_16] + Limit [LIM_15] (rows=5 width=178) Number of rows:5 - Select Operator [SEL_7] (rows=250 width=87) - Output:["_col0"] - <-Reducer 2 [SIMPLE_EDGE] - SHUFFLE [RS_6] - Group By Operator [GBY_4] (rows=250 width=87) - Output:["_col0"],keys:KEY._col0 - <-Map 1 [SIMPLE_EDGE] - SHUFFLE [RS_3] - PartitionCols:_col0 - Group By Operator [GBY_2] (rows=250 width=87) - Output:["_col0"],keys:key - Top N Key Operator [TNK_10] (rows=500 width=87) - keys:key,top n:5 - Select Operator [SEL_1] (rows=500 width=87) - Output:["key"] - TableScan [TS_0] (rows=500 width=87) - default@src,src,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] + Select Operator [SEL_14] (rows=395 width=178) + Output:["_col0","_col1"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_13] + Group By Operator [GBY_11] (rows=395 width=178) + Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_10] + PartitionCols:_col0, _col1 + Group By Operator [GBY_9] (rows=395 width=178) + Output:["_col0","_col1"],keys:_col0, _col2 + Top N Key Operator [TNK_24] (rows=791 width=178) + keys:_col0, _col2,top n:5 + Merge Join Operator [MERGEJOIN_30] (rows=791 width=178) + Conds:RS_5._col0=RS_6._col0(Left Outer),Output:["_col0","_col2"] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_5] + PartitionCols:_col0 + Select Operator [SEL_1] (rows=500 width=87) + Output:["_col0"] + TableScan [TS_0] (rows=500 width=87) + default@src,src1,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] + <-Map 5 [SIMPLE_EDGE] + SHUFFLE [RS_6] + PartitionCols:_col0 + Select Operator [SEL_4] (rows=500 width=178) + Output:["_col0","_col1"] + Filter Operator [FIL_18] (rows=500 width=178) + predicate:key is not null + TableScan [TS_2] (rows=500 width=178) + default@src,src2,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] -PREHOOK: query: SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src PREHOOK: Output: hdfs://### HDFS PATH ### -POSTHOOK: query: SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: hdfs://### HDFS PATH ### -0 -10 -100 -103 -104 -PREHOOK: query: explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src PREHOOK: Output: hdfs://### HDFS PATH ### -POSTHOOK: query: explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: hdfs://### HDFS PATH ### -PLAN VECTORIZATION: - enabled: false - enabledConditionsNotMet: [hive.vectorized.execution.enabled IS false] - -STAGE DEPENDENCIES: - Stage-1 is a root stage - Stage-0 depends on stages: Stage-1 +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: hdfs://### HDFS PATH ### +Plan optimized by CBO. -STAGE PLANS: - Stage: Stage-1 - Tez -#### A masked pattern was here #### - Edges: - Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 4 (SIMPLE_EDGE) - Reducer 3 <- Reducer 2 (SIMPLE_EDGE) -#### A masked pattern was here #### - Vertices: - Map 1 - Map Operator Tree: - TableScan - alias: src1 - filterExpr: key is not null (type: boolean) - Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator - predicate: key is not null (type: boolean) - Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: _col0 - Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: a - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Map 4 - Map Operator Tree: - TableScan - alias: src2 - filterExpr: key is not null (type: boolean) - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator - predicate: key is not null (type: boolean) - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string), value (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: a - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - value expressions: _col1 (type: string) - Reducer 2 - Reduce Operator Tree: - Merge Join Operator - condition map: - Inner Join 0 to 1 - keys: - 0 _col0 (type: string) - 1 _col0 (type: string) - outputColumnNames: _col0, _col2 - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: string), _col2 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: z - sort order: + - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: string) - Reducer 3 - Reduce Operator Tree: - Select Operator - expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Limit - Number of rows: 5 - Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE - File Output Operator - compressed: false - Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe +Vertex dependency in root stage +Reducer 2 <- Map 1 (SIMPLE_EDGE), Map 5 (SIMPLE_EDGE) +Reducer 3 <- Reducer 2 (SIMPLE_EDGE) +Reducer 4 <- Reducer 3 (SIMPLE_EDGE) - Stage: Stage-0 - Fetch Operator - limit: 5 - Processor Tree: - ListSink +Stage-0 + Fetch Operator + limit:5 + Stage-1 + Reducer 4 + File Output Operator [FS_16] + Limit [LIM_15] (rows=5 width=178) + Number of rows:5 + Select Operator [SEL_14] (rows=395 width=178) + Output:["_col0","_col1"] + <-Reducer 3 [SIMPLE_EDGE] + SHUFFLE [RS_13] + Group By Operator [GBY_11] (rows=395 width=178) + Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_10] + PartitionCols:_col0, _col1 + Group By Operator [GBY_9] (rows=395 width=178) + Output:["_col0","_col1"],keys:_col0, _col2 + Top N Key Operator [TNK_25] (rows=791 width=178) + keys:_col0, _col2,top n:5 + Merge Join Operator [MERGEJOIN_33] (rows=791 width=178) + Conds:RS_5._col0=RS_6._col0(Left Outer),Output:["_col0","_col2"] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_5] + PartitionCols:_col0 + Select Operator [SEL_1] (rows=500 width=87) + Output:["_col0"] + Top N Key Operator [TNK_23] (rows=500 width=87) + keys:key,top n:5 + TableScan [TS_0] (rows=500 width=87) + default@src,src1,Tbl:COMPLETE,Col:COMPLETE,Output:["key"] + <-Map 5 [SIMPLE_EDGE] + SHUFFLE [RS_6] + PartitionCols:_col0 + Select Operator [SEL_4] (rows=500 width=178) + Output:["_col0","_col1"] + Filter Operator [FIL_18] (rows=500 width=178) + predicate:key is not null + TableScan [TS_2] (rows=500 width=178) + default@src,src2,Tbl:COMPLETE,Col:COMPLETE,Output:["key","value"] -PREHOOK: query: SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src PREHOOK: Output: hdfs://### HDFS PATH ### -POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src POSTHOOK: Output: hdfs://### HDFS PATH ### 0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +POSTHOOK: Output: hdfs://### HDFS PATH ### 0 val_0 -0 val_0 -0 val_0 -0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: CREATE TABLE t_test( + a int, + b int, + c int +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t_test +POSTHOOK: query: CREATE TABLE t_test( + a int, + b int, + c int +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t_test +PREHOOK: query: INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@t_test +POSTHOOK: query: INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@t_test +POSTHOOK: Lineage: t_test.a SCRIPT [] +POSTHOOK: Lineage: t_test.b SCRIPT [] +POSTHOOK: Lineage: t_test.c SCRIPT [] +PREHOOK: query: EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +POSTHOOK: Output: hdfs://### HDFS PATH ### +Plan optimized by CBO. + +Vertex dependency in root stage +Reducer 2 <- Map 1 (SIMPLE_EDGE) + +Stage-0 + Fetch Operator + limit:3 + Stage-1 + Reducer 2 + File Output Operator [FS_5] + Limit [LIM_4] (rows=3 width=8) + Number of rows:3 + Select Operator [SEL_3] (rows=8 width=8) + Output:["_col0","_col1"] + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_2] + Select Operator [SEL_1] (rows=8 width=8) + Output:["_col0","_col1"] + Top N Key Operator [TNK_6] (rows=8 width=8) + keys:a, b,top n:3 + TableScan [TS_0] (rows=8 width=8) + default@t_test,t_test,Tbl:COMPLETE,Col:COMPLETE,Output:["a","b"] + +PREHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +POSTHOOK: Output: hdfs://### HDFS PATH ### +5 1 +5 1 +5 1 +PREHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +POSTHOOK: Output: hdfs://### HDFS PATH ### +5 1 +5 1 +5 1 +PREHOOK: query: EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +POSTHOOK: Output: hdfs://### HDFS PATH ### +Plan optimized by CBO. + +Vertex dependency in root stage +Reducer 2 <- Map 1 (SIMPLE_EDGE) +Reducer 3 <- Reducer 2 (SIMPLE_EDGE) + +Stage-0 + Fetch Operator + limit:3 + Stage-1 + Reducer 3 + File Output Operator [FS_9] + Limit [LIM_8] (rows=3 width=8) + Number of rows:3 + Select Operator [SEL_7] (rows=4 width=8) + Output:["_col0","_col1"] + <-Reducer 2 [SIMPLE_EDGE] + SHUFFLE [RS_6] + Group By Operator [GBY_4] (rows=4 width=8) + Output:["_col0","_col1"],keys:KEY._col0, KEY._col1 + <-Map 1 [SIMPLE_EDGE] + SHUFFLE [RS_3] + PartitionCols:_col0, _col1 + Group By Operator [GBY_2] (rows=4 width=8) + Output:["_col0","_col1"],keys:a, b + Select Operator [SEL_1] (rows=8 width=8) + Output:["a","b"] + Top N Key Operator [TNK_13] (rows=8 width=8) + keys:a, b,top n:3 + TableScan [TS_0] (rows=8 width=8) + default@t_test,t_test,Tbl:COMPLETE,Col:COMPLETE,Output:["a","b"] + +PREHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +POSTHOOK: Output: hdfs://### HDFS PATH ### +5 1 +5 2 +6 2 +PREHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +PREHOOK: Output: hdfs://### HDFS PATH ### +POSTHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +POSTHOOK: Output: hdfs://### HDFS PATH ### +5 1 +5 2 +6 2 +PREHOOK: query: DROP TABLE t_test +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@t_test +PREHOOK: Output: default@t_test +POSTHOOK: query: DROP TABLE t_test +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@t_test +POSTHOOK: Output: default@t_test diff --git ql/src/test/results/clientpositive/tez/vector_non_string_partition.q.out ql/src/test/results/clientpositive/tez/vector_non_string_partition.q.out index d449fd3754..f4d8003f03 100644 --- ql/src/test/results/clientpositive/tez/vector_non_string_partition.q.out +++ ql/src/test/results/clientpositive/tez/vector_non_string_partition.q.out @@ -68,25 +68,35 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 0:int, val 0) predicate: (cint > 0) (type: boolean) Statistics: Num rows: 1537 Data size: 12296 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cint (type: int), ctinyint (type: tinyint) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 4] + Top N Key Operator + sort order: + + keys: cint (type: int) + null sort order: z Statistics: Num rows: 1537 Data size: 12296 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int) - null sort order: z - sort order: + - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: cint (type: int), ctinyint (type: tinyint) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 4] Statistics: Num rows: 1537 Data size: 12296 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 - value expressions: _col1 (type: tinyint) + Reduce Output Operator + key expressions: _col0 (type: int) + null sort order: z + sort order: + + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 1537 Data size: 12296 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: tinyint) Execution mode: vectorized Map Vectorization: enabled: true @@ -198,24 +208,34 @@ STAGE PLANS: predicateExpression: FilterLongColGreaterLongScalar(col 0:int, val 0) predicate: (cint > 0) (type: boolean) Statistics: Num rows: 1537 Data size: 156774 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cint (type: int), cstring1 (type: string) - outputColumnNames: _col0, _col1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0, 1] + Top N Key Operator + sort order: ++ + keys: cint (type: int), cstring1 (type: string) + null sort order: zz Statistics: Num rows: 1537 Data size: 156774 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: string) - null sort order: zz - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + top n: 10 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int, col 1:string + native: true + Select Operator + expressions: cint (type: int), cstring1 (type: string) + outputColumnNames: _col0, _col1 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + projectedOutputColumnNums: [0, 1] Statistics: Num rows: 1537 Data size: 156774 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: string) + null sort order: zz + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 1537 Data size: 156774 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Execution mode: vectorized Map Vectorization: enabled: true diff --git ql/src/test/results/clientpositive/tez/vector_topnkey.q.out ql/src/test/results/clientpositive/tez/vector_topnkey.q.out index d179013e28..95812a91aa 100644 --- ql/src/test/results/clientpositive/tez/vector_topnkey.q.out +++ ql/src/test/results/clientpositive/tez/vector_topnkey.q.out @@ -87,24 +87,24 @@ STAGE PLANS: TableScan Vectorization: native: true vectorizationSchemaColumns: [0:cint1:int, 1:cint2:int, 2:cdouble:double, 3:cvarchar:varchar(50), 4:cdecimal1:decimal(10,2)/DECIMAL_64, 5:cdecimal2:decimal(38,5), 6:ROW__ID:struct] - Select Operator - expressions: cint1 (type: int) - outputColumnNames: cint1 - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumnNums: [0] + Top N Key Operator + sort order: + + keys: cint1 (type: int) + null sort order: z Statistics: Num rows: 14 Data size: 44 Basic stats: COMPLETE Column stats: COMPLETE - Top N Key Operator - sort order: + - keys: cint1 (type: int) - null sort order: z - Statistics: Num rows: 14 Data size: 44 Basic stats: COMPLETE Column stats: COMPLETE - top n: 3 - Top N Key Vectorization: - className: VectorTopNKeyOperator - keyExpressions: col 0:int + top n: 3 + Top N Key Vectorization: + className: VectorTopNKeyOperator + keyExpressions: col 0:int + native: true + Select Operator + expressions: cint1 (type: int) + outputColumnNames: cint1 + Select Vectorization: + className: VectorSelectOperator native: true + projectedOutputColumnNums: [0] + Statistics: Num rows: 14 Data size: 44 Basic stats: COMPLETE Column stats: COMPLETE Group By Operator Group By Vectorization: className: VectorGroupByOperator diff --git ql/src/test/results/clientpositive/topnkey.q.out ql/src/test/results/clientpositive/topnkey.q.out index cecbe89b1c..6d4a822588 100644 --- ql/src/test/results/clientpositive/topnkey.q.out +++ ql/src/test/results/clientpositive/topnkey.q.out @@ -1,18 +1,13 @@ -PREHOOK: query: EXPLAIN EXTENDED +PREHOOK: query: EXPLAIN SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: EXPLAIN EXTENDED +POSTHOOK: query: EXPLAIN SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -OPTIMIZED SQL: SELECT `key` AS `$f0`, SUM(CAST(SUBSTR(`value`, 5) AS INTEGER)) AS `$f1` -FROM `default`.`src` -GROUP BY `key` -ORDER BY `key` -LIMIT 5 STAGE DEPENDENCIES: Stage-1 is a root stage Stage-2 depends on stages: Stage-1 @@ -25,7 +20,6 @@ STAGE PLANS: TableScan alias: src Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE - GatherStats: false Select Operator expressions: key (type: string), UDFToInteger(substr(value, 5)) (type: int) outputColumnNames: _col0, _col1 @@ -43,65 +37,8 @@ STAGE PLANS: sort order: + Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 TopN Hash Memory Usage: 0.1 value expressions: _col1 (type: bigint) - auto parallelism: false - Path -> Alias: -#### A masked pattern was here #### - Path -> Partition: -#### A masked pattern was here #### - Partition - base file name: src - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - bucketing_version 2 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - - input format: org.apache.hadoop.mapred.TextInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat - properties: - COLUMN_STATS_ACCURATE {"BASIC_STATS":"true","COLUMN_STATS":{"key":"true","value":"true"}} - bucket_count -1 - bucketing_version 2 - column.name.delimiter , - columns key,value - columns.comments 'default','default' - columns.types string:string -#### A masked pattern was here #### - name default.src - numFiles 1 - numRows 500 - rawDataSize 5312 - serialization.ddl struct src { string key, string value} - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - totalSize 5812 -#### A masked pattern was here #### - serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - name: default.src - name: default.src - Truncated Path -> Alias: - /src [$hdt$_0:src] - Needs Tagging: false Reduce Operator Tree: Group By Operator aggregations: sum(VALUE._col0) @@ -111,66 +48,22 @@ STAGE PLANS: Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1 - columns.types string,bigint - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false Stage: Stage-2 Map Reduce Map Operator Tree: TableScan - GatherStats: false Reduce Output Operator key expressions: _col0 (type: string) null sort order: z sort order: + Statistics: Num rows: 250 Data size: 23750 Basic stats: COMPLETE Column stats: COMPLETE - tag: -1 - TopN: 5 TopN Hash Memory Usage: 0.1 value expressions: _col1 (type: bigint) - auto parallelism: false - Path -> Alias: -#### A masked pattern was here #### - Path -> Partition: -#### A masked pattern was here #### - Partition - base file name: -mr-10004 - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1 - columns.types string,bigint - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - column.name.delimiter , - columns _col0,_col1 - columns.types string,bigint - escape.delim \ - serialization.lib org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - Truncated Path -> Alias: -#### A masked pattern was here #### - Needs Tagging: false Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: bigint) @@ -181,26 +74,11 @@ STAGE PLANS: Statistics: Num rows: 5 Data size: 475 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - GlobalTableId: 0 -#### A masked pattern was here #### - NumFilesPerFileSink: 1 Statistics: Num rows: 5 Data size: 475 Basic stats: COMPLETE Column stats: COMPLETE -#### A masked pattern was here #### table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - properties: - columns _col0,_col1 - columns.types string:bigint - escape.delim \ - hive.serialization.extend.additional.nesting.levels true - serialization.escape.crlf true - serialization.format 1 - serialization.lib org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe - TotalFiles: 1 - GatherStats: false - MultiFileSpray: false Stage: Stage-0 Fetch Operator @@ -208,6 +86,19 @@ STAGE PLANS: Processor Tree: ListSink +PREHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +0 0 +10 10 +100 200 +103 206 +104 208 PREHOOK: query: SELECT key, SUM(CAST(SUBSTR(value,5) AS INT)) FROM src GROUP BY key ORDER BY key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src @@ -222,50 +113,95 @@ POSTHOOK: Input: default@src 103 206 104 208 PREHOOK: query: EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### POSTHOOK: query: EXPLAIN -SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### STAGE DEPENDENCIES: Stage-1 is a root stage Stage-2 depends on stages: Stage-1 - Stage-0 depends on stages: Stage-2 + Stage-3 depends on stages: Stage-2 + Stage-0 depends on stages: Stage-3 STAGE PLANS: Stage: Stage-1 Map Reduce Map Operator Tree: TableScan - alias: src + alias: src1 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: key (type: string) - outputColumnNames: key + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator - keys: key (type: string) - minReductionHashAggr: 0.99 - mode: hash - outputColumnNames: _col0 - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: a + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE + TableScan + alias: src2 + filterExpr: key is not null (type: boolean) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + Filter Operator + predicate: key is not null (type: boolean) + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: key (type: string), value (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE Reduce Output Operator key expressions: _col0 (type: string) - null sort order: z + null sort order: a sort order: + Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE - TopN Hash Memory Usage: 0.1 + Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE + value expressions: _col1 (type: string) + Reduce Operator Tree: + Join Operator + condition map: + Left Outer Join 0 to 1 + keys: + 0 _col0 (type: string) + 1 _col0 (type: string) + outputColumnNames: _col0, _col2 + Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + keys: _col0 (type: string), _col2 (type: string) + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: za + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 Reduce Operator Tree: Group By Operator - keys: KEY._col0 (type: string) + keys: KEY._col0 (type: string), KEY._col1 (type: string) mode: mergepartial - outputColumnNames: _col0 - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false table: @@ -273,7 +209,7 @@ STAGE PLANS: output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - Stage: Stage-2 + Stage: Stage-3 Map Reduce Map Operator Tree: TableScan @@ -281,19 +217,20 @@ STAGE PLANS: key expressions: _col0 (type: string) null sort order: z sort order: + - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE TopN Hash Memory Usage: 0.1 + value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: string) - outputColumnNames: _col0 - Statistics: Num rows: 250 Data size: 21750 Basic stats: COMPLETE Column stats: COMPLETE + expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 5 - Statistics: Num rows: 5 Data size: 435 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false - Statistics: Num rows: 5 Data size: 435 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -305,37 +242,47 @@ STAGE PLANS: Processor Tree: ListSink -PREHOOK: query: SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: SELECT key FROM src GROUP BY key ORDER BY key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -0 -10 -100 -103 -104 -PREHOOK: query: explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: explain vectorization detail -SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN +SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### -PLAN VECTORIZATION: - enabled: false - enabledConditionsNotMet: [hive.vectorized.execution.enabled IS false] - STAGE DEPENDENCIES: Stage-1 is a root stage Stage-2 depends on stages: Stage-1 - Stage-0 depends on stages: Stage-2 + Stage-3 depends on stages: Stage-2 + Stage-0 depends on stages: Stage-3 STAGE PLANS: Stage: Stage-1 @@ -343,21 +290,17 @@ STAGE PLANS: Map Operator Tree: TableScan alias: src1 - filterExpr: key is not null (type: boolean) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Filter Operator - predicate: key is not null (type: boolean) + Select Operator + expressions: key (type: string) + outputColumnNames: _col0 Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: key (type: string) - outputColumnNames: _col0 + Reduce Output Operator + key expressions: _col0 (type: string) + null sort order: a + sort order: + + Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: string) - null sort order: a - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE TableScan alias: src2 filterExpr: key is not null (type: boolean) @@ -379,16 +322,18 @@ STAGE PLANS: Reduce Operator Tree: Join Operator condition map: - Inner Join 0 to 1 + Left Outer Join 0 to 1 keys: 0 _col0 (type: string) 1 _col0 (type: string) outputColumnNames: _col0, _col2 Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: _col0 (type: string), _col2 (type: string) + Group By Operator + keys: _col0 (type: string), _col2 (type: string) + minReductionHashAggr: 0.99 + mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE File Output Operator compressed: false table: @@ -397,21 +342,45 @@ STAGE PLANS: serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string), _col1 (type: string) + null sort order: aa + sort order: ++ + Map-reduce partition columns: _col0 (type: string), _col1 (type: string) + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: string), KEY._col1 (type: string) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE + 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-3 Map Reduce Map Operator Tree: TableScan Reduce Output Operator key expressions: _col0 (type: string) - null sort order: z + null sort order: a sort order: + - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE TopN Hash Memory Usage: 0.1 value expressions: _col1 (type: string) Reduce Operator Tree: Select Operator expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 791 Data size: 140798 Basic stats: COMPLETE Column stats: COMPLETE + Statistics: Num rows: 395 Data size: 70310 Basic stats: COMPLETE Column stats: COMPLETE Limit Number of rows: 5 Statistics: Num rows: 5 Data size: 890 Basic stats: COMPLETE Column stats: COMPLETE @@ -429,16 +398,253 @@ STAGE PLANS: Processor Tree: ListSink -PREHOOK: query: SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 PREHOOK: type: QUERY PREHOOK: Input: default@src #### A masked pattern was here #### -POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 JOIN src src2 ON (src1.key = src2.key) ORDER BY src1.key LIMIT 5 +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 POSTHOOK: type: QUERY POSTHOOK: Input: default@src #### A masked pattern was here #### 0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: SELECT src1.key, src2.value FROM src src1 LEFT OUTER JOIN src src2 ON (src1.key = src2.key) GROUP BY src1.key, src2.value ORDER BY src1.key NULLS FIRST LIMIT 5 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### 0 val_0 -0 val_0 -0 val_0 -0 val_0 +10 val_10 +100 val_100 +103 val_103 +104 val_104 +PREHOOK: query: CREATE TABLE t_test( + a int, + b int, + c int +) +PREHOOK: type: CREATETABLE +PREHOOK: Output: database:default +PREHOOK: Output: default@t_test +POSTHOOK: query: CREATE TABLE t_test( + a int, + b int, + c int +) +POSTHOOK: type: CREATETABLE +POSTHOOK: Output: database:default +POSTHOOK: Output: default@t_test +PREHOOK: query: INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2) +PREHOOK: type: QUERY +PREHOOK: Input: _dummy_database@_dummy_table +PREHOOK: Output: default@t_test +POSTHOOK: query: INSERT INTO t_test VALUES +(5, 2, 3), +(6, 2, 1), +(7, 8, 4), (7, 8, 4), (7, 8, 4), +(5, 1, 2), (5, 1, 2), (5, 1, 2) +POSTHOOK: type: QUERY +POSTHOOK: Input: _dummy_database@_dummy_table +POSTHOOK: Output: default@t_test +POSTHOOK: Lineage: t_test.a SCRIPT [] +POSTHOOK: Lineage: t_test.b SCRIPT [] +POSTHOOK: Lineage: t_test.c SCRIPT [] +PREHOOK: query: EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN +SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: t_test + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: a (type: int), b (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Limit + Number of rows: 3 + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: 3 + Processor Tree: + ListSink + +PREHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 1 +5 1 +PREHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 1 +5 1 +PREHOOK: query: EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: EXPLAIN +SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: t_test + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Select Operator + expressions: a (type: int), b (type: int) + outputColumnNames: a, b + Statistics: Num rows: 8 Data size: 64 Basic stats: COMPLETE Column stats: COMPLETE + Group By Operator + keys: a (type: int), b (type: int) + minReductionHashAggr: 0.99 + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + null sort order: zz + sort order: ++ + Map-reduce partition columns: _col0 (type: int), _col1 (type: int) + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reduce Operator Tree: + Group By Operator + keys: KEY._col0 (type: int), KEY._col1 (type: int) + mode: mergepartial + outputColumnNames: _col0, _col1 + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + null sort order: zz + sort order: ++ + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + TopN Hash Memory Usage: 0.1 + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 4 Data size: 32 Basic stats: COMPLETE Column stats: COMPLETE + Limit + Number of rows: 3 + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + File Output Operator + compressed: false + Statistics: Num rows: 3 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: 3 + Processor Tree: + ListSink + +PREHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 2 +6 2 +PREHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +PREHOOK: type: QUERY +PREHOOK: Input: default@t_test +#### A masked pattern was here #### +POSTHOOK: query: SELECT a, b FROM t_test GROUP BY a, b ORDER BY a, b LIMIT 3 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@t_test +#### A masked pattern was here #### +5 1 +5 2 +6 2 +PREHOOK: query: DROP TABLE t_test +PREHOOK: type: DROPTABLE +PREHOOK: Input: default@t_test +PREHOOK: Output: default@t_test +POSTHOOK: query: DROP TABLE t_test +POSTHOOK: type: DROPTABLE +POSTHOOK: Input: default@t_test +POSTHOOK: Output: default@t_test