diff --git a/common/src/java/org/apache/hadoop/hive/conf/HiveConf.java b/common/src/java/org/apache/hadoop/hive/conf/HiveConf.java index 6678de6..f510458 100644 --- a/common/src/java/org/apache/hadoop/hive/conf/HiveConf.java +++ b/common/src/java/org/apache/hadoop/hive/conf/HiveConf.java @@ -1273,6 +1273,8 @@ public void setSparkConfigUpdated(boolean isSparkConfigUpdated) { "Whether to update stale indexes automatically"), HIVEOPTPPD("hive.optimize.ppd", true, "Whether to enable predicate pushdown"), + HIVEOPTPPD_WINDOWING("hive.optimize.ppd.windowing", true, + "Whether to enable predicate pushdown through windowing"), HIVEPPDRECOGNIZETRANSITIVITY("hive.ppd.recognizetransivity", true, "Whether to transitively replicate predicate filters over equijoin conditions."), HIVEPPDREMOVEDUPLICATEFILTERS("hive.ppd.remove.duplicatefilters", true, diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java index 1c15012..8688fd7 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/HiveCalciteUtil.java @@ -719,56 +719,108 @@ public Void visitCall(org.apache.calcite.rex.RexCall call) { return deterministic; } - public static boolean isDeterministicFuncOnLiterals(RexNode expr) { - boolean deterministicFuncOnLiterals = true; + private static class DeterMinisticFuncVisitorImpl extends RexVisitorImpl { + protected DeterMinisticFuncVisitorImpl() { + super(true); + } - RexVisitor visitor = new RexVisitorImpl(true) { - @Override - public Void visitCall(org.apache.calcite.rex.RexCall call) { - if (!call.getOperator().isDeterministic()) { - throw new Util.FoundOne(call); - } - return super.visitCall(call); + @Override + public Void visitCall(org.apache.calcite.rex.RexCall call) { + if (!call.getOperator().isDeterministic()) { + throw new Util.FoundOne(call); } + return super.visitCall(call); + } + + @Override + public Void visitCorrelVariable(RexCorrelVariable correlVariable) { + throw new Util.FoundOne(correlVariable); + } + + @Override + public Void visitLocalRef(RexLocalRef localRef) { + throw new Util.FoundOne(localRef); + } + + @Override + public Void visitOver(RexOver over) { + throw new Util.FoundOne(over); + } + + @Override + public Void visitDynamicParam(RexDynamicParam dynamicParam) { + throw new Util.FoundOne(dynamicParam); + } + + @Override + public Void visitRangeRef(RexRangeRef rangeRef) { + throw new Util.FoundOne(rangeRef); + } + + @Override + public Void visitFieldAccess(RexFieldAccess fieldAccess) { + throw new Util.FoundOne(fieldAccess); + } + } + + public static boolean isDeterministicFuncOnLiterals(RexNode expr) { + boolean deterministicFuncOnLiterals = true; + RexVisitor visitor = new DeterMinisticFuncVisitorImpl() { @Override public Void visitInputRef(RexInputRef inputRef) { throw new Util.FoundOne(inputRef); } + }; - @Override - public Void visitLocalRef(RexLocalRef localRef) { - throw new Util.FoundOne(localRef); - } + try { + expr.accept(visitor); + } catch (Util.FoundOne e) { + deterministicFuncOnLiterals = false; + } - @Override - public Void visitOver(RexOver over) { - throw new Util.FoundOne(over); - } + return deterministicFuncOnLiterals; + } - @Override - public Void visitDynamicParam(RexDynamicParam dynamicParam) { - throw new Util.FoundOne(dynamicParam); + public List getDeterministicFuncWithSingleInputRef(List exprs, + final Set validInputRefs) { + List determExprsWithSingleRef = new ArrayList(); + for (RexNode e : exprs) { + if (isDeterministicFuncWithSingleInputRef(e, validInputRefs)) { + determExprsWithSingleRef.add(e); } + } + return determExprsWithSingleRef; + } - @Override - public Void visitRangeRef(RexRangeRef rangeRef) { - throw new Util.FoundOne(rangeRef); - } + public static boolean isDeterministicFuncWithSingleInputRef(RexNode expr, + final Set validInputRefs) { + boolean deterministicFuncWithSingleInputRef = true; + + RexVisitor visitor = new DeterMinisticFuncVisitorImpl() { + Set inputRefs = new HashSet(); @Override - public Void visitFieldAccess(RexFieldAccess fieldAccess) { - throw new Util.FoundOne(fieldAccess); + public Void visitInputRef(RexInputRef inputRef) { + if (validInputRefs.contains(inputRef.getIndex())) { + inputRefs.add(inputRef.getIndex()); + if (inputRefs.size() > 1) { + throw new Util.FoundOne(inputRef); + } + } else { + throw new Util.FoundOne(inputRef); + } + return null; } }; try { expr.accept(visitor); } catch (Util.FoundOne e) { - deterministicFuncOnLiterals = false; + deterministicFuncWithSingleInputRef = false; } - return deterministicFuncOnLiterals; + return deterministicFuncWithSingleInputRef; } public static ImmutableMap getColInfoMap(List hiveCols, diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterProjectTransposeRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterProjectTransposeRule.java index 1e947c3..d675bc4 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterProjectTransposeRule.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveFilterProjectTransposeRule.java @@ -17,34 +17,54 @@ */ package org.apache.hadoop.hive.ql.optimizer.calcite.rules; +import java.util.ArrayList; +import java.util.HashSet; +import java.util.List; +import java.util.Set; + import org.apache.calcite.plan.RelOptRuleCall; +import org.apache.calcite.plan.RelOptUtil; +import org.apache.calcite.rel.RelNode; import org.apache.calcite.rel.core.Filter; import org.apache.calcite.rel.core.Project; import org.apache.calcite.rel.core.RelFactories.FilterFactory; import org.apache.calcite.rel.core.RelFactories.ProjectFactory; import org.apache.calcite.rel.rules.FilterProjectTransposeRule; +import org.apache.calcite.rel.type.RelDataTypeFactory; +import org.apache.calcite.rex.RexCall; +import org.apache.calcite.rex.RexInputRef; import org.apache.calcite.rex.RexNode; +import org.apache.calcite.rex.RexOver; +import org.apache.calcite.rex.RexUtil; +import org.apache.calcite.tools.RelBuilder; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveCalciteUtil; import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories; import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveProject; public class HiveFilterProjectTransposeRule extends FilterProjectTransposeRule { + public static final HiveFilterProjectTransposeRule INSTANCE_DETERMINISTIC_WINDOWING = + new HiveFilterProjectTransposeRule(Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, + HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, true, true); + public static final HiveFilterProjectTransposeRule INSTANCE_DETERMINISTIC = new HiveFilterProjectTransposeRule(Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, - HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, true); + HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, true, false); public static final HiveFilterProjectTransposeRule INSTANCE = new HiveFilterProjectTransposeRule(Filter.class, HiveRelFactories.HIVE_FILTER_FACTORY, - HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, false); + HiveProject.class, HiveRelFactories.HIVE_PROJECT_FACTORY, false, false); private final boolean onlyDeterministic; - public HiveFilterProjectTransposeRule(Class filterClass, + private final boolean pushThroughWindowing; + + private HiveFilterProjectTransposeRule(Class filterClass, FilterFactory filterFactory, Class projectClass, - ProjectFactory projectFactory, boolean onlyDeterministic) { + ProjectFactory projectFactory, boolean onlyDeterministic,boolean pushThroughWindowing) { super(filterClass, filterFactory, projectClass, projectFactory); this.onlyDeterministic = onlyDeterministic; + this.pushThroughWindowing = pushThroughWindowing; } @Override @@ -58,4 +78,107 @@ public boolean matches(RelOptRuleCall call) { return super.matches(call); } + public void onMatch(RelOptRuleCall call) { + final Filter filter = call.rel(0); + final Project origproject = call.rel(1); + RexNode filterCond = filter.getCondition(); + + if (RexUtil.containsCorrelation(filterCond)) { + // If there is a correlation condition anywhere in the filter, don't + // push this filter past project since in some cases it can prevent a + // Correlate from being de-correlated. + return; + } + + if (RexOver.containsOver(origproject.getProjects(), null)) { + RexNode origFilterCond = filterCond; + filterCond = null; + if (pushThroughWindowing) { + Set commonPartitionKeys = getCommonPartitionCols(origproject.getProjects()); + List newPartKeyFilConds = new ArrayList(); + + // TODO: + // 1) Handle compound partition keys (partition by k1+k2) + // 2) When multiple window clauses are present in same select Even if + // Predicate can not pushed past all of them, we might still able to + // push + // it below some of them. + // Ex: select * from (select key, value, avg(c_int) over (partition by + // key), sum(c_float) over(partition by value) from t1)t1 where value < + // 10 + // --> select * from (select key, value, avg(c_int) over (partition by + // key) from (select key, value, sum(c_float) over(partition by value) + // from t1 where value < 10)t1)t2 + if (!commonPartitionKeys.isEmpty()) { + List conjuctiveElements = RelOptUtil.conjunctions(origFilterCond); + for (RexNode ce : conjuctiveElements) { + RexNode newCondition = RelOptUtil.pushPastProject(ce, origproject); + if (HiveCalciteUtil.isDeterministicFuncWithSingleInputRef(newCondition, + commonPartitionKeys)) { + newPartKeyFilConds.add(newCondition); + } + } + filterCond = RexUtil.composeConjunction(filter.getCluster().getRexBuilder(), + newPartKeyFilConds, true); + } + } + } + + if (filterCond != null) { + RelNode newProjRel = getNewProject(filterCond, origproject, filter.getCluster() + .getTypeFactory(), call.builder()); + call.transformTo(newProjRel); + } + } + + private static RelNode getNewProject(RexNode filterCondition, Project oldProj, + RelDataTypeFactory typeFactory, RelBuilder relBuilder) { + + // convert the filter to one that references the child of the project + RexNode newCondition = RelOptUtil.pushPastProject(filterCondition, oldProj); + + // Remove cast of BOOLEAN NOT NULL to BOOLEAN or vice versa. Filter accepts + // nullable and not-nullable conditions, but a CAST might get in the way of + // other rewrites. + if (RexUtil.isNullabilityCast(typeFactory, newCondition)) { + newCondition = ((RexCall) newCondition).getOperands().get(0); + } + + RelNode newFilterRel = relBuilder.push(oldProj.getInput()).filter(newCondition).build(); + + RelNode newProjRel = relBuilder.push(newFilterRel) + .project(oldProj.getProjects(), oldProj.getRowType().getFieldNames()).build(); + return newProjRel; + } + + private static Set getCommonPartitionCols(List projections) { + RexOver overClause; + boolean firstOverClause = true; + Set commonPartitionKeys = new HashSet(); + + for (RexNode expr : projections) { + if (expr instanceof RexOver) { + overClause = (RexOver) expr; + + if (firstOverClause) { + firstOverClause = false; + commonPartitionKeys.addAll(getPartitionCols(overClause.getWindow().partitionKeys)); + } else { + commonPartitionKeys.retainAll(getPartitionCols(overClause.getWindow().partitionKeys)); + } + } + } + + return commonPartitionKeys; + } + + private static List getPartitionCols(List partitionKeys) { + List pCols = new ArrayList(); + for (RexNode key : partitionKeys) { + if (key instanceof RexInputRef) { + pCols.add(((RexInputRef) key).getIndex()); + } + } + return pCols; + } } diff --git a/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java b/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java index e2d404b..1d4e415 100644 --- a/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java +++ b/ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java @@ -1070,7 +1070,8 @@ private RelNode applyPreJoinOrderingTransforms(RelNode basePlan, RelMetadataProv // constant propagation, constant folding perfLogger.PerfLogBegin(this.getClass().getName(), PerfLogger.OPTIMIZER); basePlan = hepPlan(basePlan, true, mdProvider, executorProvider, HepMatchOrder.BOTTOM_UP, - HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC, + conf.getBoolVar(HiveConf.ConfVars.HIVEOPTPPD_WINDOWING) ? HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC_WINDOWING + : HiveFilterProjectTransposeRule.INSTANCE_DETERMINISTIC, HiveFilterSetOpTransposeRule.INSTANCE, HiveFilterSortTransposeRule.INSTANCE, HiveFilterJoinRule.JOIN, diff --git a/ql/src/test/queries/clientpositive/ppd_windowing1.q b/ql/src/test/queries/clientpositive/ppd_windowing1.q new file mode 100644 index 0000000..f380eab --- /dev/null +++ b/ql/src/test/queries/clientpositive/ppd_windowing1.q @@ -0,0 +1,46 @@ +set hive.mapred.mode=nonstrict; +set hive.optimize.ppd=true; +set hive.ppd.remove.duplicatefilters=false; + +-- Test simple PPD through Windowing +EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > '2'; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > 2; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where cast(key as int) > 2; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2; +EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test PPD through Windowing where predicate is a subset of partition keys +EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > '2'; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > 2; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where cast(key as int) > 2; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2; +EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF is same +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > '2'; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > 2; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; +EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF has different args +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > '2'; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > 2; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; +EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test predicate is not getting pushed down when multiple windows are involved and they don't have common partition keys +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, avg(value) over(partition by value) as c2 from src)r1 where key > '2'; + + +-- Test predicate is not getting pushed down when window has compound partition key +EXPLAIN select * from (SELECT key, sum(key) over(partition by key + 2) as c1 from src)r1 where key > '2'; +EXPLAIN select * from (SELECT key, sum(key) over(partition by key + value) as c1 from src)r1 where key > '2'; + +-- Test predicate is not getting pushed down when predicate involves more than one col +EXPLAIN select * from (SELECT key, value, sum(key) over(partition by key, value) as c1 from src)r1 where (key + value) > '2'; +EXPLAIN select * from (SELECT key, value, sum(key) over(partition by key + value) as c1 from src)r1 where (key + value) > '2'; +EXPLAIN select * from (SELECT (cast(key as int))+(cast(value as int)) as key, sum(key) over(partition by key) as c1 from src)r1 where key > 2; diff --git a/ql/src/test/queries/clientpositive/ppd_windowing2.q b/ql/src/test/queries/clientpositive/ppd_windowing2.q new file mode 100644 index 0000000..abfe89e --- /dev/null +++ b/ql/src/test/queries/clientpositive/ppd_windowing2.q @@ -0,0 +1,49 @@ +set hive.mapred.mode=nonstrict; +set hive.optimize.ppd=true; +set hive.ppd.remove.duplicatefilters=false; + + +-- NOTE: This is a correctness test. If you regen q.out, regen it with optimization turned off + +-- Test simple PPD through Windowing +select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > '2'; +select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > 2; +select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where cast(key as int) > 2; +select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2; +select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test PPD through Windowing where predicate is a subset of partition keys +select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > '2'; +select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > 2; +select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where cast(key as int) > 2; +select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2; +select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF is same +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > '2'; +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > 2; +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; +select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF has different args +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > '2'; +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > 2; +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; +select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2; + + +-- Test predicate is not getting pushed down when multiple windows are involved and they don't have common partition keys +select * from (SELECT key, sum(key) over(partition by key,value) as c1, avg(value) over(partition by value) as c2 from src)r1 where key > '2'; + + +-- Test predicate is not getting pushed down when window has compound partition key +select * from (SELECT key, sum(key) over(partition by key + 2) as c1 from src)r1 where key > '2'; +select * from (SELECT key, sum(key) over(partition by key + value) as c1 from src)r1 where key > '2'; + +-- Test predicate is not getting pushed down when predicate involves more than one col +select * from (SELECT key, value, sum(key) over(partition by key, value) as c1 from src)r1 where (key + value) > '2'; +select * from (SELECT key, value, sum(key) over(partition by key + value) as c1 from src)r1 where (key + value) > '2'; +select * from (SELECT (cast(key as int))+(cast(value as int)) as key, sum(key) over(partition by key) as c1 from src)r1 where key > 2; diff --git a/ql/src/test/results/clientpositive/ppd_windowing1.q.out b/ql/src/test/results/clientpositive/ppd_windowing1.q.out new file mode 100644 index 0000000..1db69bb --- /dev/null +++ b/ql/src/test/results/clientpositive/ppd_windowing1.q.out @@ -0,0 +1,2029 @@ +PREHOOK: query: -- Test simple PPD through Windowing +EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test simple PPD through Windowing +EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (key > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string) + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0 + partition by: _col0 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToDouble(key) > 2.0) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string) + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0 + partition by: _col0 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where cast(key as int) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where cast(key as int) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToInteger(key) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string) + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0 + partition by: _col0 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToInteger(key) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string) + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0 + partition by: _col0 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (((UDFToInteger(key) + 2) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string) + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0 + partition by: _col0 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: (UDFToInteger(_col0) + 2) (type: int), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys +EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys +EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (key > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToDouble(key) > 2.0) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where cast(key as int) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where cast(key as int) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToInteger(key) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToInteger(key) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (((UDFToInteger(key) + 2) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: (UDFToInteger(_col0) + 2) (type: int), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF is same +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF is same +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (key > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col1 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToDouble(key) > 2.0) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col1 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToInteger(key) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col1 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (((UDFToInteger(key) + 2) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col1 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: (UDFToInteger(_col1) + 2) (type: int), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF has different args +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF has different args +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (key > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double), _col1 (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string, _col2: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col2 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (UDFToDouble(key) > 2.0) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double), _col1 (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string, _col2: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col2 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToInteger(key) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double), _col1 (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string, _col2: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col2 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (((UDFToInteger(key) + 2) + 1) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, sum_window_0 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double), _col1 (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), KEY.reducesinkkey0 (type: string), VALUE._col1 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string, _col2: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col1 + partition by: _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_1 + arguments: _col2 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: (UDFToInteger(_col1) + 2) (type: int), _col0 (type: double), sum_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: -- Test predicate is not getting pushed down when multiple windows are involved and they don't have common partition keys +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, avg(value) over(partition by value) as c2 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test predicate is not getting pushed down when multiple windows are involved and they don't have common partition keys +EXPLAIN select * from (SELECT key, sum(key) over(partition by key,value) as c1, avg(value) over(partition by value) as c2 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-2 depends on stages: Stage-1 + Stage-0 depends on stages: Stage-2 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, sum_window_0 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + table: + input format: org.apache.hadoop.mapred.SequenceFileInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat + serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + + Stage: Stage-2 + Map Reduce + Map Operator Tree: + TableScan + Reduce Output Operator + key expressions: _col1 (type: string) + sort order: + + Map-reduce partition columns: _col1 (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: sum_window_0 (type: double), _col0 (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: double), VALUE._col1 (type: string), KEY.reducesinkkey0 (type: string) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: double, _col1: string, _col2: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col2 + partition by: _col2 + raw input shape: + window functions: + window function definition + alias: avg_window_1 + arguments: _col2 + name: avg + window function: GenericUDAFAverageEvaluatorDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: string), _col0 (type: double), avg_window_1 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (_col0 > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: -- Test predicate is not getting pushed down when window has compound partition key +EXPLAIN select * from (SELECT key, sum(key) over(partition by key + 2) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test predicate is not getting pushed down when window has compound partition key +EXPLAIN select * from (SELECT key, sum(key) over(partition by key + 2) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: (UDFToDouble(key) + UDFToDouble(2)) (type: double) + sort order: + + Map-reduce partition columns: (UDFToDouble(key) + UDFToDouble(2)) (type: double) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: key (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: string) + outputColumnNames: _col0 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: (UDFToDouble(_col0) + UDFToDouble(2)) + partition by: (UDFToDouble(_col0) + UDFToDouble(2)) + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (_col0 > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key + value) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, sum(key) over(partition by key + value) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: (UDFToDouble(key) + UDFToDouble(value)) (type: double) + sort order: + + Map-reduce partition columns: (UDFToDouble(key) + UDFToDouble(value)) (type: double) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: key (type: string), value (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: (UDFToDouble(_col0) + UDFToDouble(_col1)) + partition by: (UDFToDouble(_col0) + UDFToDouble(_col1)) + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: (_col0 > '2') (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: -- Test predicate is not getting pushed down when predicate involves more than one col +EXPLAIN select * from (SELECT key, value, sum(key) over(partition by key, value) as c1 from src)r1 where (key + value) > '2' +PREHOOK: type: QUERY +POSTHOOK: query: -- Test predicate is not getting pushed down when predicate involves more than one col +EXPLAIN select * from (SELECT key, value, sum(key) over(partition by key, value) as c1 from src)r1 where (key + value) > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string), value (type: string) + sort order: ++ + Map-reduce partition columns: key (type: string), value (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0, _col1 + partition by: _col0, _col1 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToDouble(_col0) + UDFToDouble(_col1)) > 2.0) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT key, value, sum(key) over(partition by key + value) as c1 from src)r1 where (key + value) > '2' +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT key, value, sum(key) over(partition by key + value) as c1 from src)r1 where (key + value) > '2' +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: (UDFToDouble(key) + UDFToDouble(value)) (type: double) + sort order: + + Map-reduce partition columns: (UDFToDouble(key) + UDFToDouble(value)) (type: double) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: key (type: string), value (type: string) + Reduce Operator Tree: + Select Operator + expressions: VALUE._col0 (type: string), VALUE._col1 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: (UDFToDouble(_col0) + UDFToDouble(_col1)) + partition by: (UDFToDouble(_col0) + UDFToDouble(_col1)) + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToDouble(_col0) + UDFToDouble(_col1)) > 2.0) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + +PREHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+(cast(value as int)) as key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +PREHOOK: type: QUERY +POSTHOOK: query: EXPLAIN select * from (SELECT (cast(key as int))+(cast(value as int)) as key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +POSTHOOK: type: QUERY +STAGE DEPENDENCIES: + Stage-1 is a root stage + Stage-0 depends on stages: Stage-1 + +STAGE PLANS: + Stage: Stage-1 + Map Reduce + Map Operator Tree: + TableScan + alias: src + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: key (type: string) + sort order: + + Map-reduce partition columns: key (type: string) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + value expressions: value (type: string) + Reduce Operator Tree: + Select Operator + expressions: KEY.reducesinkkey0 (type: string), VALUE._col0 (type: string) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + PTF Operator + Function definitions: + Input definition + input alias: ptf_0 + output shape: _col0: string, _col1: string + type: WINDOWING + Windowing table definition + input alias: ptf_1 + name: windowingtablefunction + order by: _col0 + partition by: _col0 + raw input shape: + window functions: + window function definition + alias: sum_window_0 + arguments: _col0 + name: sum + window function: GenericUDAFSumDouble + window frame: PRECEDING(MAX)~FOLLOWING(MAX) + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: string), _col1 (type: string), sum_window_0 (type: double) + outputColumnNames: _col0, _col1, _col2 + Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE + Filter Operator + predicate: ((UDFToInteger(_col0) + UDFToInteger(_col1)) > 2) (type: boolean) + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: (UDFToInteger(_col0) + UDFToInteger(_col1)) (type: int), _col2 (type: double) + outputColumnNames: _col0, _col1 + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + File Output Operator + compressed: false + Statistics: Num rows: 166 Data size: 1763 Basic stats: COMPLETE Column stats: NONE + table: + input format: org.apache.hadoop.mapred.TextInputFormat + output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat + serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe + + Stage: Stage-0 + Fetch Operator + limit: -1 + Processor Tree: + ListSink + diff --git a/ql/src/test/results/clientpositive/ppd_windowing2.q.out b/ql/src/test/results/clientpositive/ppd_windowing2.q.out new file mode 100644 index 0000000..0e2081b --- /dev/null +++ b/ql/src/test/results/clientpositive/ppd_windowing2.q.out @@ -0,0 +1,9841 @@ +PREHOOK: query: -- NOTE: This is a correctness test. If you regen q.out, regen it with optimization turned off + +-- Test simple PPD through Windowing +select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- NOTE: This is a correctness test. If you regen q.out, regen it with optimization turned off + +-- Test simple PPD through Windowing +select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 +100 200.0 +100 200.0 +103 206.0 +103 206.0 +104 208.0 +104 208.0 +105 105.0 +11 11.0 +111 111.0 +113 226.0 +113 226.0 +114 114.0 +116 116.0 +118 236.0 +118 236.0 +119 357.0 +119 357.0 +119 357.0 +12 24.0 +12 24.0 +120 240.0 +120 240.0 +125 250.0 +125 250.0 +126 126.0 +128 384.0 +128 384.0 +128 384.0 +129 258.0 +129 258.0 +131 131.0 +133 133.0 +134 268.0 +134 268.0 +136 136.0 +137 274.0 +137 274.0 +138 552.0 +138 552.0 +138 552.0 +138 552.0 +143 143.0 +145 145.0 +146 292.0 +146 292.0 +149 298.0 +149 298.0 +15 30.0 +15 30.0 +150 150.0 +152 304.0 +152 304.0 +153 153.0 +155 155.0 +156 156.0 +157 157.0 +158 158.0 +160 160.0 +162 162.0 +163 163.0 +164 328.0 +164 328.0 +165 330.0 +165 330.0 +166 166.0 +167 501.0 +167 501.0 +167 501.0 +168 168.0 +169 676.0 +169 676.0 +169 676.0 +169 676.0 +17 17.0 +170 170.0 +172 344.0 +172 344.0 +174 348.0 +174 348.0 +175 350.0 +175 350.0 +176 352.0 +176 352.0 +177 177.0 +178 178.0 +179 358.0 +179 358.0 +18 36.0 +18 36.0 +180 180.0 +181 181.0 +183 183.0 +186 186.0 +187 561.0 +187 561.0 +187 561.0 +189 189.0 +19 19.0 +190 190.0 +191 382.0 +191 382.0 +192 192.0 +193 579.0 +193 579.0 +193 579.0 +194 194.0 +195 390.0 +195 390.0 +196 196.0 +197 394.0 +197 394.0 +199 597.0 +199 597.0 +199 597.0 +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where cast(key as int) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where cast(key as int) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 +100 200.0 +100 200.0 +103 206.0 +103 206.0 +104 208.0 +104 208.0 +105 105.0 +11 11.0 +111 111.0 +113 226.0 +113 226.0 +114 114.0 +116 116.0 +118 236.0 +118 236.0 +119 357.0 +119 357.0 +119 357.0 +12 24.0 +12 24.0 +120 240.0 +120 240.0 +125 250.0 +125 250.0 +126 126.0 +128 384.0 +128 384.0 +128 384.0 +129 258.0 +129 258.0 +131 131.0 +133 133.0 +134 268.0 +134 268.0 +136 136.0 +137 274.0 +137 274.0 +138 552.0 +138 552.0 +138 552.0 +138 552.0 +143 143.0 +145 145.0 +146 292.0 +146 292.0 +149 298.0 +149 298.0 +15 30.0 +15 30.0 +150 150.0 +152 304.0 +152 304.0 +153 153.0 +155 155.0 +156 156.0 +157 157.0 +158 158.0 +160 160.0 +162 162.0 +163 163.0 +164 328.0 +164 328.0 +165 330.0 +165 330.0 +166 166.0 +167 501.0 +167 501.0 +167 501.0 +168 168.0 +169 676.0 +169 676.0 +169 676.0 +169 676.0 +17 17.0 +170 170.0 +172 344.0 +172 344.0 +174 348.0 +174 348.0 +175 350.0 +175 350.0 +176 352.0 +176 352.0 +177 177.0 +178 178.0 +179 358.0 +179 358.0 +18 36.0 +18 36.0 +180 180.0 +181 181.0 +183 183.0 +186 186.0 +187 561.0 +187 561.0 +187 561.0 +189 189.0 +19 19.0 +190 190.0 +191 382.0 +191 382.0 +192 192.0 +193 579.0 +193 579.0 +193 579.0 +194 194.0 +195 390.0 +195 390.0 +196 196.0 +197 394.0 +197 394.0 +199 597.0 +199 597.0 +199 597.0 +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 +100 200.0 +100 200.0 +103 206.0 +103 206.0 +104 208.0 +104 208.0 +105 105.0 +11 11.0 +111 111.0 +113 226.0 +113 226.0 +114 114.0 +116 116.0 +118 236.0 +118 236.0 +119 357.0 +119 357.0 +119 357.0 +12 24.0 +12 24.0 +120 240.0 +120 240.0 +125 250.0 +125 250.0 +126 126.0 +128 384.0 +128 384.0 +128 384.0 +129 258.0 +129 258.0 +131 131.0 +133 133.0 +134 268.0 +134 268.0 +136 136.0 +137 274.0 +137 274.0 +138 552.0 +138 552.0 +138 552.0 +138 552.0 +143 143.0 +145 145.0 +146 292.0 +146 292.0 +149 298.0 +149 298.0 +15 30.0 +15 30.0 +150 150.0 +152 304.0 +152 304.0 +153 153.0 +155 155.0 +156 156.0 +157 157.0 +158 158.0 +160 160.0 +162 162.0 +163 163.0 +164 328.0 +164 328.0 +165 330.0 +165 330.0 +166 166.0 +167 501.0 +167 501.0 +167 501.0 +168 168.0 +169 676.0 +169 676.0 +169 676.0 +169 676.0 +17 17.0 +170 170.0 +172 344.0 +172 344.0 +174 348.0 +174 348.0 +175 350.0 +175 350.0 +176 352.0 +176 352.0 +177 177.0 +178 178.0 +179 358.0 +179 358.0 +18 36.0 +18 36.0 +180 180.0 +181 181.0 +183 183.0 +186 186.0 +187 561.0 +187 561.0 +187 561.0 +189 189.0 +19 19.0 +190 190.0 +191 382.0 +191 382.0 +192 192.0 +193 579.0 +193 579.0 +193 579.0 +194 194.0 +195 390.0 +195 390.0 +196 196.0 +197 394.0 +197 394.0 +199 597.0 +199 597.0 +199 597.0 +2 2.0 +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +2 0.0 +2 0.0 +2 0.0 +12 10.0 +102 200.0 +102 200.0 +105 206.0 +105 206.0 +106 208.0 +106 208.0 +107 105.0 +13 11.0 +113 111.0 +115 226.0 +115 226.0 +116 114.0 +118 116.0 +120 236.0 +120 236.0 +121 357.0 +121 357.0 +121 357.0 +14 24.0 +14 24.0 +122 240.0 +122 240.0 +127 250.0 +127 250.0 +128 126.0 +130 384.0 +130 384.0 +130 384.0 +131 258.0 +131 258.0 +133 131.0 +135 133.0 +136 268.0 +136 268.0 +138 136.0 +139 274.0 +139 274.0 +140 552.0 +140 552.0 +140 552.0 +140 552.0 +145 143.0 +147 145.0 +148 292.0 +148 292.0 +151 298.0 +151 298.0 +17 30.0 +17 30.0 +152 150.0 +154 304.0 +154 304.0 +155 153.0 +157 155.0 +158 156.0 +159 157.0 +160 158.0 +162 160.0 +164 162.0 +165 163.0 +166 328.0 +166 328.0 +167 330.0 +167 330.0 +168 166.0 +169 501.0 +169 501.0 +169 501.0 +170 168.0 +171 676.0 +171 676.0 +171 676.0 +171 676.0 +19 17.0 +172 170.0 +174 344.0 +174 344.0 +176 348.0 +176 348.0 +177 350.0 +177 350.0 +178 352.0 +178 352.0 +179 177.0 +180 178.0 +181 358.0 +181 358.0 +20 36.0 +20 36.0 +182 180.0 +183 181.0 +185 183.0 +188 186.0 +189 561.0 +189 561.0 +189 561.0 +191 189.0 +21 19.0 +192 190.0 +193 382.0 +193 382.0 +194 192.0 +195 579.0 +195 579.0 +195 579.0 +196 194.0 +197 390.0 +197 390.0 +198 196.0 +199 394.0 +199 394.0 +201 597.0 +201 597.0 +201 597.0 +4 2.0 +22 20.0 +202 400.0 +202 400.0 +203 201.0 +204 202.0 +205 406.0 +205 406.0 +207 410.0 +207 410.0 +209 414.0 +209 414.0 +210 624.0 +210 624.0 +210 624.0 +211 418.0 +211 418.0 +215 426.0 +215 426.0 +216 214.0 +218 432.0 +218 432.0 +219 434.0 +219 434.0 +220 218.0 +221 438.0 +221 438.0 +223 442.0 +223 442.0 +224 222.0 +225 446.0 +225 446.0 +226 448.0 +226 448.0 +228 226.0 +230 228.0 +231 458.0 +231 458.0 +232 1150.0 +232 1150.0 +232 1150.0 +232 1150.0 +232 1150.0 +235 466.0 +235 466.0 +237 235.0 +239 474.0 +239 474.0 +240 476.0 +240 476.0 +241 478.0 +241 478.0 +26 48.0 +26 48.0 +243 241.0 +244 484.0 +244 484.0 +246 244.0 +249 247.0 +250 248.0 +251 249.0 +254 252.0 +257 510.0 +257 510.0 +258 512.0 +258 512.0 +259 257.0 +260 258.0 +28 52.0 +28 52.0 +262 260.0 +264 262.0 +265 263.0 +267 530.0 +267 530.0 +268 266.0 +29 27.0 +274 544.0 +274 544.0 +275 819.0 +275 819.0 +275 819.0 +276 274.0 +277 275.0 +279 1108.0 +279 1108.0 +279 1108.0 +279 1108.0 +280 556.0 +280 556.0 +30 28.0 +282 560.0 +282 560.0 +283 562.0 +283 562.0 +284 564.0 +284 564.0 +285 283.0 +286 284.0 +287 285.0 +288 286.0 +289 287.0 +290 576.0 +290 576.0 +291 289.0 +293 291.0 +294 292.0 +298 296.0 +300 894.0 +300 894.0 +300 894.0 +32 30.0 +304 302.0 +307 305.0 +308 306.0 +309 614.0 +309 614.0 +310 308.0 +311 618.0 +311 618.0 +312 310.0 +313 933.0 +313 933.0 +313 933.0 +317 315.0 +318 948.0 +318 948.0 +318 948.0 +319 634.0 +319 634.0 +320 954.0 +320 954.0 +320 954.0 +323 642.0 +323 642.0 +324 644.0 +324 644.0 +325 323.0 +327 650.0 +327 650.0 +329 981.0 +329 981.0 +329 981.0 +35 33.0 +333 662.0 +333 662.0 +334 332.0 +335 666.0 +335 666.0 +337 335.0 +338 336.0 +340 338.0 +341 339.0 +36 34.0 +343 341.0 +344 684.0 +344 684.0 +346 688.0 +346 688.0 +347 345.0 +350 1740.0 +350 1740.0 +350 1740.0 +350 1740.0 +350 1740.0 +37 105.0 +37 105.0 +37 105.0 +353 351.0 +355 706.0 +355 706.0 +358 356.0 +362 360.0 +364 362.0 +366 364.0 +367 365.0 +368 366.0 +369 734.0 +369 734.0 +370 368.0 +371 1107.0 +371 1107.0 +371 1107.0 +39 74.0 +39 74.0 +375 373.0 +376 374.0 +377 375.0 +379 377.0 +380 378.0 +381 379.0 +384 764.0 +384 764.0 +386 1152.0 +386 1152.0 +386 1152.0 +388 386.0 +391 389.0 +394 392.0 +395 393.0 +396 394.0 +397 790.0 +397 790.0 +398 1188.0 +398 1188.0 +398 1188.0 +399 794.0 +399 794.0 +401 798.0 +401 798.0 +6 4.0 +402 400.0 +403 2005.0 +403 2005.0 +403 2005.0 +403 2005.0 +403 2005.0 +404 402.0 +405 1209.0 +405 1209.0 +405 1209.0 +406 808.0 +406 808.0 +408 1624.0 +408 1624.0 +408 1624.0 +408 1624.0 +409 407.0 +411 1227.0 +411 1227.0 +411 1227.0 +43 41.0 +413 411.0 +415 826.0 +415 826.0 +416 828.0 +416 828.0 +419 1251.0 +419 1251.0 +419 1251.0 +420 418.0 +421 419.0 +44 84.0 +44 84.0 +423 421.0 +426 848.0 +426 848.0 +429 427.0 +431 858.0 +431 858.0 +45 43.0 +432 1290.0 +432 1290.0 +432 1290.0 +433 1293.0 +433 1293.0 +433 1293.0 +434 432.0 +437 435.0 +438 436.0 +439 437.0 +440 1314.0 +440 1314.0 +440 1314.0 +441 878.0 +441 878.0 +46 44.0 +445 443.0 +446 444.0 +448 446.0 +450 448.0 +451 449.0 +454 452.0 +455 453.0 +456 1362.0 +456 1362.0 +456 1362.0 +457 455.0 +459 457.0 +460 916.0 +460 916.0 +461 918.0 +461 918.0 +462 460.0 +464 924.0 +464 924.0 +465 926.0 +465 926.0 +468 1398.0 +468 1398.0 +468 1398.0 +469 467.0 +470 1872.0 +470 1872.0 +470 1872.0 +470 1872.0 +471 2345.0 +471 2345.0 +471 2345.0 +471 2345.0 +471 2345.0 +49 47.0 +472 470.0 +474 472.0 +477 475.0 +479 477.0 +480 956.0 +480 956.0 +481 479.0 +482 1440.0 +482 1440.0 +482 1440.0 +483 481.0 +484 482.0 +485 483.0 +486 484.0 +487 485.0 +489 487.0 +491 1956.0 +491 1956.0 +491 1956.0 +491 1956.0 +492 490.0 +493 491.0 +494 984.0 +494 984.0 +495 493.0 +496 494.0 +497 495.0 +498 496.0 +499 497.0 +500 1494.0 +500 1494.0 +500 1494.0 +7 15.0 +7 15.0 +7 15.0 +53 102.0 +53 102.0 +55 53.0 +56 54.0 +59 57.0 +60 116.0 +60 116.0 +66 64.0 +67 65.0 +68 66.0 +69 134.0 +69 134.0 +71 69.0 +72 210.0 +72 210.0 +72 210.0 +74 144.0 +74 144.0 +76 74.0 +78 152.0 +78 152.0 +79 77.0 +80 78.0 +10 8.0 +82 80.0 +84 82.0 +85 166.0 +85 166.0 +86 168.0 +86 168.0 +87 85.0 +88 86.0 +89 87.0 +11 9.0 +92 270.0 +92 270.0 +92 270.0 +94 92.0 +97 190.0 +97 190.0 +98 96.0 +99 194.0 +99 194.0 +100 196.0 +100 196.0 +PREHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys +select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys +select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where key > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 +100 200.0 +100 200.0 +103 206.0 +103 206.0 +104 208.0 +104 208.0 +105 105.0 +11 11.0 +111 111.0 +113 226.0 +113 226.0 +114 114.0 +116 116.0 +118 236.0 +118 236.0 +119 357.0 +119 357.0 +119 357.0 +12 24.0 +12 24.0 +120 240.0 +120 240.0 +125 250.0 +125 250.0 +126 126.0 +128 384.0 +128 384.0 +128 384.0 +129 258.0 +129 258.0 +131 131.0 +133 133.0 +134 268.0 +134 268.0 +136 136.0 +137 274.0 +137 274.0 +138 552.0 +138 552.0 +138 552.0 +138 552.0 +143 143.0 +145 145.0 +146 292.0 +146 292.0 +149 298.0 +149 298.0 +15 30.0 +15 30.0 +150 150.0 +152 304.0 +152 304.0 +153 153.0 +155 155.0 +156 156.0 +157 157.0 +158 158.0 +160 160.0 +162 162.0 +163 163.0 +164 328.0 +164 328.0 +165 330.0 +165 330.0 +166 166.0 +167 501.0 +167 501.0 +167 501.0 +168 168.0 +169 676.0 +169 676.0 +169 676.0 +169 676.0 +17 17.0 +170 170.0 +172 344.0 +172 344.0 +174 348.0 +174 348.0 +175 350.0 +175 350.0 +176 352.0 +176 352.0 +177 177.0 +178 178.0 +179 358.0 +179 358.0 +18 36.0 +18 36.0 +180 180.0 +181 181.0 +183 183.0 +186 186.0 +187 561.0 +187 561.0 +187 561.0 +189 189.0 +19 19.0 +190 190.0 +191 382.0 +191 382.0 +192 192.0 +193 579.0 +193 579.0 +193 579.0 +194 194.0 +195 390.0 +195 390.0 +196 196.0 +197 394.0 +197 394.0 +199 597.0 +199 597.0 +199 597.0 +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where cast(key as int) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where cast(key as int) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 +100 200.0 +100 200.0 +103 206.0 +103 206.0 +104 208.0 +104 208.0 +105 105.0 +11 11.0 +111 111.0 +113 226.0 +113 226.0 +114 114.0 +116 116.0 +118 236.0 +118 236.0 +119 357.0 +119 357.0 +119 357.0 +12 24.0 +12 24.0 +120 240.0 +120 240.0 +125 250.0 +125 250.0 +126 126.0 +128 384.0 +128 384.0 +128 384.0 +129 258.0 +129 258.0 +131 131.0 +133 133.0 +134 268.0 +134 268.0 +136 136.0 +137 274.0 +137 274.0 +138 552.0 +138 552.0 +138 552.0 +138 552.0 +143 143.0 +145 145.0 +146 292.0 +146 292.0 +149 298.0 +149 298.0 +15 30.0 +15 30.0 +150 150.0 +152 304.0 +152 304.0 +153 153.0 +155 155.0 +156 156.0 +157 157.0 +158 158.0 +160 160.0 +162 162.0 +163 163.0 +164 328.0 +164 328.0 +165 330.0 +165 330.0 +166 166.0 +167 501.0 +167 501.0 +167 501.0 +168 168.0 +169 676.0 +169 676.0 +169 676.0 +169 676.0 +17 17.0 +170 170.0 +172 344.0 +172 344.0 +174 348.0 +174 348.0 +175 350.0 +175 350.0 +176 352.0 +176 352.0 +177 177.0 +178 178.0 +179 358.0 +179 358.0 +18 36.0 +18 36.0 +180 180.0 +181 181.0 +183 183.0 +186 186.0 +187 561.0 +187 561.0 +187 561.0 +189 189.0 +19 19.0 +190 190.0 +191 382.0 +191 382.0 +192 192.0 +193 579.0 +193 579.0 +193 579.0 +194 194.0 +195 390.0 +195 390.0 +196 196.0 +197 394.0 +197 394.0 +199 597.0 +199 597.0 +199 597.0 +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 +100 200.0 +100 200.0 +103 206.0 +103 206.0 +104 208.0 +104 208.0 +105 105.0 +11 11.0 +111 111.0 +113 226.0 +113 226.0 +114 114.0 +116 116.0 +118 236.0 +118 236.0 +119 357.0 +119 357.0 +119 357.0 +12 24.0 +12 24.0 +120 240.0 +120 240.0 +125 250.0 +125 250.0 +126 126.0 +128 384.0 +128 384.0 +128 384.0 +129 258.0 +129 258.0 +131 131.0 +133 133.0 +134 268.0 +134 268.0 +136 136.0 +137 274.0 +137 274.0 +138 552.0 +138 552.0 +138 552.0 +138 552.0 +143 143.0 +145 145.0 +146 292.0 +146 292.0 +149 298.0 +149 298.0 +15 30.0 +15 30.0 +150 150.0 +152 304.0 +152 304.0 +153 153.0 +155 155.0 +156 156.0 +157 157.0 +158 158.0 +160 160.0 +162 162.0 +163 163.0 +164 328.0 +164 328.0 +165 330.0 +165 330.0 +166 166.0 +167 501.0 +167 501.0 +167 501.0 +168 168.0 +169 676.0 +169 676.0 +169 676.0 +169 676.0 +17 17.0 +170 170.0 +172 344.0 +172 344.0 +174 348.0 +174 348.0 +175 350.0 +175 350.0 +176 352.0 +176 352.0 +177 177.0 +178 178.0 +179 358.0 +179 358.0 +18 36.0 +18 36.0 +180 180.0 +181 181.0 +183 183.0 +186 186.0 +187 561.0 +187 561.0 +187 561.0 +189 189.0 +19 19.0 +190 190.0 +191 382.0 +191 382.0 +192 192.0 +193 579.0 +193 579.0 +193 579.0 +194 194.0 +195 390.0 +195 390.0 +196 196.0 +197 394.0 +197 394.0 +199 597.0 +199 597.0 +199 597.0 +2 2.0 +20 20.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +24 48.0 +24 48.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +26 52.0 +26 52.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +27 27.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +28 28.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +30 30.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +33 33.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +34 34.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +35 105.0 +35 105.0 +35 105.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +37 74.0 +37 74.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +4 4.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +41 41.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +42 84.0 +42 84.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +43 43.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +44 44.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +47 47.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +5 15.0 +5 15.0 +5 15.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +8 8.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +9 9.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +PREHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key, value) as c1 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +2 0.0 +2 0.0 +2 0.0 +12 10.0 +102 200.0 +102 200.0 +105 206.0 +105 206.0 +106 208.0 +106 208.0 +107 105.0 +13 11.0 +113 111.0 +115 226.0 +115 226.0 +116 114.0 +118 116.0 +120 236.0 +120 236.0 +121 357.0 +121 357.0 +121 357.0 +14 24.0 +14 24.0 +122 240.0 +122 240.0 +127 250.0 +127 250.0 +128 126.0 +130 384.0 +130 384.0 +130 384.0 +131 258.0 +131 258.0 +133 131.0 +135 133.0 +136 268.0 +136 268.0 +138 136.0 +139 274.0 +139 274.0 +140 552.0 +140 552.0 +140 552.0 +140 552.0 +145 143.0 +147 145.0 +148 292.0 +148 292.0 +151 298.0 +151 298.0 +17 30.0 +17 30.0 +152 150.0 +154 304.0 +154 304.0 +155 153.0 +157 155.0 +158 156.0 +159 157.0 +160 158.0 +162 160.0 +164 162.0 +165 163.0 +166 328.0 +166 328.0 +167 330.0 +167 330.0 +168 166.0 +169 501.0 +169 501.0 +169 501.0 +170 168.0 +171 676.0 +171 676.0 +171 676.0 +171 676.0 +19 17.0 +172 170.0 +174 344.0 +174 344.0 +176 348.0 +176 348.0 +177 350.0 +177 350.0 +178 352.0 +178 352.0 +179 177.0 +180 178.0 +181 358.0 +181 358.0 +20 36.0 +20 36.0 +182 180.0 +183 181.0 +185 183.0 +188 186.0 +189 561.0 +189 561.0 +189 561.0 +191 189.0 +21 19.0 +192 190.0 +193 382.0 +193 382.0 +194 192.0 +195 579.0 +195 579.0 +195 579.0 +196 194.0 +197 390.0 +197 390.0 +198 196.0 +199 394.0 +199 394.0 +201 597.0 +201 597.0 +201 597.0 +4 2.0 +22 20.0 +202 400.0 +202 400.0 +203 201.0 +204 202.0 +205 406.0 +205 406.0 +207 410.0 +207 410.0 +209 414.0 +209 414.0 +210 624.0 +210 624.0 +210 624.0 +211 418.0 +211 418.0 +215 426.0 +215 426.0 +216 214.0 +218 432.0 +218 432.0 +219 434.0 +219 434.0 +220 218.0 +221 438.0 +221 438.0 +223 442.0 +223 442.0 +224 222.0 +225 446.0 +225 446.0 +226 448.0 +226 448.0 +228 226.0 +230 228.0 +231 458.0 +231 458.0 +232 1150.0 +232 1150.0 +232 1150.0 +232 1150.0 +232 1150.0 +235 466.0 +235 466.0 +237 235.0 +239 474.0 +239 474.0 +240 476.0 +240 476.0 +241 478.0 +241 478.0 +26 48.0 +26 48.0 +243 241.0 +244 484.0 +244 484.0 +246 244.0 +249 247.0 +250 248.0 +251 249.0 +254 252.0 +257 510.0 +257 510.0 +258 512.0 +258 512.0 +259 257.0 +260 258.0 +28 52.0 +28 52.0 +262 260.0 +264 262.0 +265 263.0 +267 530.0 +267 530.0 +268 266.0 +29 27.0 +274 544.0 +274 544.0 +275 819.0 +275 819.0 +275 819.0 +276 274.0 +277 275.0 +279 1108.0 +279 1108.0 +279 1108.0 +279 1108.0 +280 556.0 +280 556.0 +30 28.0 +282 560.0 +282 560.0 +283 562.0 +283 562.0 +284 564.0 +284 564.0 +285 283.0 +286 284.0 +287 285.0 +288 286.0 +289 287.0 +290 576.0 +290 576.0 +291 289.0 +293 291.0 +294 292.0 +298 296.0 +300 894.0 +300 894.0 +300 894.0 +32 30.0 +304 302.0 +307 305.0 +308 306.0 +309 614.0 +309 614.0 +310 308.0 +311 618.0 +311 618.0 +312 310.0 +313 933.0 +313 933.0 +313 933.0 +317 315.0 +318 948.0 +318 948.0 +318 948.0 +319 634.0 +319 634.0 +320 954.0 +320 954.0 +320 954.0 +323 642.0 +323 642.0 +324 644.0 +324 644.0 +325 323.0 +327 650.0 +327 650.0 +329 981.0 +329 981.0 +329 981.0 +35 33.0 +333 662.0 +333 662.0 +334 332.0 +335 666.0 +335 666.0 +337 335.0 +338 336.0 +340 338.0 +341 339.0 +36 34.0 +343 341.0 +344 684.0 +344 684.0 +346 688.0 +346 688.0 +347 345.0 +350 1740.0 +350 1740.0 +350 1740.0 +350 1740.0 +350 1740.0 +37 105.0 +37 105.0 +37 105.0 +353 351.0 +355 706.0 +355 706.0 +358 356.0 +362 360.0 +364 362.0 +366 364.0 +367 365.0 +368 366.0 +369 734.0 +369 734.0 +370 368.0 +371 1107.0 +371 1107.0 +371 1107.0 +39 74.0 +39 74.0 +375 373.0 +376 374.0 +377 375.0 +379 377.0 +380 378.0 +381 379.0 +384 764.0 +384 764.0 +386 1152.0 +386 1152.0 +386 1152.0 +388 386.0 +391 389.0 +394 392.0 +395 393.0 +396 394.0 +397 790.0 +397 790.0 +398 1188.0 +398 1188.0 +398 1188.0 +399 794.0 +399 794.0 +401 798.0 +401 798.0 +6 4.0 +402 400.0 +403 2005.0 +403 2005.0 +403 2005.0 +403 2005.0 +403 2005.0 +404 402.0 +405 1209.0 +405 1209.0 +405 1209.0 +406 808.0 +406 808.0 +408 1624.0 +408 1624.0 +408 1624.0 +408 1624.0 +409 407.0 +411 1227.0 +411 1227.0 +411 1227.0 +43 41.0 +413 411.0 +415 826.0 +415 826.0 +416 828.0 +416 828.0 +419 1251.0 +419 1251.0 +419 1251.0 +420 418.0 +421 419.0 +44 84.0 +44 84.0 +423 421.0 +426 848.0 +426 848.0 +429 427.0 +431 858.0 +431 858.0 +45 43.0 +432 1290.0 +432 1290.0 +432 1290.0 +433 1293.0 +433 1293.0 +433 1293.0 +434 432.0 +437 435.0 +438 436.0 +439 437.0 +440 1314.0 +440 1314.0 +440 1314.0 +441 878.0 +441 878.0 +46 44.0 +445 443.0 +446 444.0 +448 446.0 +450 448.0 +451 449.0 +454 452.0 +455 453.0 +456 1362.0 +456 1362.0 +456 1362.0 +457 455.0 +459 457.0 +460 916.0 +460 916.0 +461 918.0 +461 918.0 +462 460.0 +464 924.0 +464 924.0 +465 926.0 +465 926.0 +468 1398.0 +468 1398.0 +468 1398.0 +469 467.0 +470 1872.0 +470 1872.0 +470 1872.0 +470 1872.0 +471 2345.0 +471 2345.0 +471 2345.0 +471 2345.0 +471 2345.0 +49 47.0 +472 470.0 +474 472.0 +477 475.0 +479 477.0 +480 956.0 +480 956.0 +481 479.0 +482 1440.0 +482 1440.0 +482 1440.0 +483 481.0 +484 482.0 +485 483.0 +486 484.0 +487 485.0 +489 487.0 +491 1956.0 +491 1956.0 +491 1956.0 +491 1956.0 +492 490.0 +493 491.0 +494 984.0 +494 984.0 +495 493.0 +496 494.0 +497 495.0 +498 496.0 +499 497.0 +500 1494.0 +500 1494.0 +500 1494.0 +7 15.0 +7 15.0 +7 15.0 +53 102.0 +53 102.0 +55 53.0 +56 54.0 +59 57.0 +60 116.0 +60 116.0 +66 64.0 +67 65.0 +68 66.0 +69 134.0 +69 134.0 +71 69.0 +72 210.0 +72 210.0 +72 210.0 +74 144.0 +74 144.0 +76 74.0 +78 152.0 +78 152.0 +79 77.0 +80 78.0 +10 8.0 +82 80.0 +84 82.0 +85 166.0 +85 166.0 +86 168.0 +86 168.0 +87 85.0 +88 86.0 +89 87.0 +11 9.0 +92 270.0 +92 270.0 +92 270.0 +94 92.0 +97 190.0 +97 190.0 +98 96.0 +99 194.0 +99 194.0 +100 196.0 +100 196.0 +PREHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF is same +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF is same +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +20 20.0 20.0 +200 400.0 400.0 +200 400.0 400.0 +201 201.0 201.0 +202 202.0 202.0 +203 406.0 406.0 +203 406.0 406.0 +205 410.0 410.0 +205 410.0 410.0 +207 414.0 414.0 +207 414.0 414.0 +208 624.0 624.0 +208 624.0 624.0 +208 624.0 624.0 +209 418.0 418.0 +209 418.0 418.0 +213 426.0 426.0 +213 426.0 426.0 +214 214.0 214.0 +216 432.0 432.0 +216 432.0 432.0 +217 434.0 434.0 +217 434.0 434.0 +218 218.0 218.0 +219 438.0 438.0 +219 438.0 438.0 +221 442.0 442.0 +221 442.0 442.0 +222 222.0 222.0 +223 446.0 446.0 +223 446.0 446.0 +224 448.0 448.0 +224 448.0 448.0 +226 226.0 226.0 +228 228.0 228.0 +229 458.0 458.0 +229 458.0 458.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +233 466.0 466.0 +233 466.0 466.0 +235 235.0 235.0 +237 474.0 474.0 +237 474.0 474.0 +238 476.0 476.0 +238 476.0 476.0 +239 478.0 478.0 +239 478.0 478.0 +24 48.0 48.0 +24 48.0 48.0 +241 241.0 241.0 +242 484.0 484.0 +242 484.0 484.0 +244 244.0 244.0 +247 247.0 247.0 +248 248.0 248.0 +249 249.0 249.0 +252 252.0 252.0 +255 510.0 510.0 +255 510.0 510.0 +256 512.0 512.0 +256 512.0 512.0 +257 257.0 257.0 +258 258.0 258.0 +26 52.0 52.0 +26 52.0 52.0 +260 260.0 260.0 +262 262.0 262.0 +263 263.0 263.0 +265 530.0 530.0 +265 530.0 530.0 +266 266.0 266.0 +27 27.0 27.0 +272 544.0 544.0 +272 544.0 544.0 +273 819.0 819.0 +273 819.0 819.0 +273 819.0 819.0 +274 274.0 274.0 +275 275.0 275.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +278 556.0 556.0 +278 556.0 556.0 +28 28.0 28.0 +280 560.0 560.0 +280 560.0 560.0 +281 562.0 562.0 +281 562.0 562.0 +282 564.0 564.0 +282 564.0 564.0 +283 283.0 283.0 +284 284.0 284.0 +285 285.0 285.0 +286 286.0 286.0 +287 287.0 287.0 +288 576.0 576.0 +288 576.0 576.0 +289 289.0 289.0 +291 291.0 291.0 +292 292.0 292.0 +296 296.0 296.0 +298 894.0 894.0 +298 894.0 894.0 +298 894.0 894.0 +30 30.0 30.0 +302 302.0 302.0 +305 305.0 305.0 +306 306.0 306.0 +307 614.0 614.0 +307 614.0 614.0 +308 308.0 308.0 +309 618.0 618.0 +309 618.0 618.0 +310 310.0 310.0 +311 933.0 933.0 +311 933.0 933.0 +311 933.0 933.0 +315 315.0 315.0 +316 948.0 948.0 +316 948.0 948.0 +316 948.0 948.0 +317 634.0 634.0 +317 634.0 634.0 +318 954.0 954.0 +318 954.0 954.0 +318 954.0 954.0 +321 642.0 642.0 +321 642.0 642.0 +322 644.0 644.0 +322 644.0 644.0 +323 323.0 323.0 +325 650.0 650.0 +325 650.0 650.0 +327 981.0 981.0 +327 981.0 981.0 +327 981.0 981.0 +33 33.0 33.0 +331 662.0 662.0 +331 662.0 662.0 +332 332.0 332.0 +333 666.0 666.0 +333 666.0 666.0 +335 335.0 335.0 +336 336.0 336.0 +338 338.0 338.0 +339 339.0 339.0 +34 34.0 34.0 +341 341.0 341.0 +342 684.0 684.0 +342 684.0 684.0 +344 688.0 688.0 +344 688.0 688.0 +345 345.0 345.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +35 105.0 105.0 +35 105.0 105.0 +35 105.0 105.0 +351 351.0 351.0 +353 706.0 706.0 +353 706.0 706.0 +356 356.0 356.0 +360 360.0 360.0 +362 362.0 362.0 +364 364.0 364.0 +365 365.0 365.0 +366 366.0 366.0 +367 734.0 734.0 +367 734.0 734.0 +368 368.0 368.0 +369 1107.0 1107.0 +369 1107.0 1107.0 +369 1107.0 1107.0 +37 74.0 74.0 +37 74.0 74.0 +373 373.0 373.0 +374 374.0 374.0 +375 375.0 375.0 +377 377.0 377.0 +378 378.0 378.0 +379 379.0 379.0 +382 764.0 764.0 +382 764.0 764.0 +384 1152.0 1152.0 +384 1152.0 1152.0 +384 1152.0 1152.0 +386 386.0 386.0 +389 389.0 389.0 +392 392.0 392.0 +393 393.0 393.0 +394 394.0 394.0 +395 790.0 790.0 +395 790.0 790.0 +396 1188.0 1188.0 +396 1188.0 1188.0 +396 1188.0 1188.0 +397 794.0 794.0 +397 794.0 794.0 +399 798.0 798.0 +399 798.0 798.0 +4 4.0 4.0 +400 400.0 400.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +402 402.0 402.0 +403 1209.0 1209.0 +403 1209.0 1209.0 +403 1209.0 1209.0 +404 808.0 808.0 +404 808.0 808.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +407 407.0 407.0 +409 1227.0 1227.0 +409 1227.0 1227.0 +409 1227.0 1227.0 +41 41.0 41.0 +411 411.0 411.0 +413 826.0 826.0 +413 826.0 826.0 +414 828.0 828.0 +414 828.0 828.0 +417 1251.0 1251.0 +417 1251.0 1251.0 +417 1251.0 1251.0 +418 418.0 418.0 +419 419.0 419.0 +42 84.0 84.0 +42 84.0 84.0 +421 421.0 421.0 +424 848.0 848.0 +424 848.0 848.0 +427 427.0 427.0 +429 858.0 858.0 +429 858.0 858.0 +43 43.0 43.0 +430 1290.0 1290.0 +430 1290.0 1290.0 +430 1290.0 1290.0 +431 1293.0 1293.0 +431 1293.0 1293.0 +431 1293.0 1293.0 +432 432.0 432.0 +435 435.0 435.0 +436 436.0 436.0 +437 437.0 437.0 +438 1314.0 1314.0 +438 1314.0 1314.0 +438 1314.0 1314.0 +439 878.0 878.0 +439 878.0 878.0 +44 44.0 44.0 +443 443.0 443.0 +444 444.0 444.0 +446 446.0 446.0 +448 448.0 448.0 +449 449.0 449.0 +452 452.0 452.0 +453 453.0 453.0 +454 1362.0 1362.0 +454 1362.0 1362.0 +454 1362.0 1362.0 +455 455.0 455.0 +457 457.0 457.0 +458 916.0 916.0 +458 916.0 916.0 +459 918.0 918.0 +459 918.0 918.0 +460 460.0 460.0 +462 924.0 924.0 +462 924.0 924.0 +463 926.0 926.0 +463 926.0 926.0 +466 1398.0 1398.0 +466 1398.0 1398.0 +466 1398.0 1398.0 +467 467.0 467.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +47 47.0 47.0 +470 470.0 470.0 +472 472.0 472.0 +475 475.0 475.0 +477 477.0 477.0 +478 956.0 956.0 +478 956.0 956.0 +479 479.0 479.0 +480 1440.0 1440.0 +480 1440.0 1440.0 +480 1440.0 1440.0 +481 481.0 481.0 +482 482.0 482.0 +483 483.0 483.0 +484 484.0 484.0 +485 485.0 485.0 +487 487.0 487.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +490 490.0 490.0 +491 491.0 491.0 +492 984.0 984.0 +492 984.0 984.0 +493 493.0 493.0 +494 494.0 494.0 +495 495.0 495.0 +496 496.0 496.0 +497 497.0 497.0 +498 1494.0 1494.0 +498 1494.0 1494.0 +498 1494.0 1494.0 +5 15.0 15.0 +5 15.0 15.0 +5 15.0 15.0 +51 102.0 102.0 +51 102.0 102.0 +53 53.0 53.0 +54 54.0 54.0 +57 57.0 57.0 +58 116.0 116.0 +58 116.0 116.0 +64 64.0 64.0 +65 65.0 65.0 +66 66.0 66.0 +67 134.0 134.0 +67 134.0 134.0 +69 69.0 69.0 +70 210.0 210.0 +70 210.0 210.0 +70 210.0 210.0 +72 144.0 144.0 +72 144.0 144.0 +74 74.0 74.0 +76 152.0 152.0 +76 152.0 152.0 +77 77.0 77.0 +78 78.0 78.0 +8 8.0 8.0 +80 80.0 80.0 +82 82.0 82.0 +83 166.0 166.0 +83 166.0 166.0 +84 168.0 168.0 +84 168.0 168.0 +85 85.0 85.0 +86 86.0 86.0 +87 87.0 87.0 +9 9.0 9.0 +90 270.0 270.0 +90 270.0 270.0 +90 270.0 270.0 +92 92.0 92.0 +95 190.0 190.0 +95 190.0 190.0 +96 96.0 96.0 +97 194.0 194.0 +97 194.0 194.0 +98 196.0 196.0 +98 196.0 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where key > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 10.0 +100 200.0 200.0 +100 200.0 200.0 +103 206.0 206.0 +103 206.0 206.0 +104 208.0 208.0 +104 208.0 208.0 +105 105.0 105.0 +11 11.0 11.0 +111 111.0 111.0 +113 226.0 226.0 +113 226.0 226.0 +114 114.0 114.0 +116 116.0 116.0 +118 236.0 236.0 +118 236.0 236.0 +119 357.0 357.0 +119 357.0 357.0 +119 357.0 357.0 +12 24.0 24.0 +12 24.0 24.0 +120 240.0 240.0 +120 240.0 240.0 +125 250.0 250.0 +125 250.0 250.0 +126 126.0 126.0 +128 384.0 384.0 +128 384.0 384.0 +128 384.0 384.0 +129 258.0 258.0 +129 258.0 258.0 +131 131.0 131.0 +133 133.0 133.0 +134 268.0 268.0 +134 268.0 268.0 +136 136.0 136.0 +137 274.0 274.0 +137 274.0 274.0 +138 552.0 552.0 +138 552.0 552.0 +138 552.0 552.0 +138 552.0 552.0 +143 143.0 143.0 +145 145.0 145.0 +146 292.0 292.0 +146 292.0 292.0 +149 298.0 298.0 +149 298.0 298.0 +15 30.0 30.0 +15 30.0 30.0 +150 150.0 150.0 +152 304.0 304.0 +152 304.0 304.0 +153 153.0 153.0 +155 155.0 155.0 +156 156.0 156.0 +157 157.0 157.0 +158 158.0 158.0 +160 160.0 160.0 +162 162.0 162.0 +163 163.0 163.0 +164 328.0 328.0 +164 328.0 328.0 +165 330.0 330.0 +165 330.0 330.0 +166 166.0 166.0 +167 501.0 501.0 +167 501.0 501.0 +167 501.0 501.0 +168 168.0 168.0 +169 676.0 676.0 +169 676.0 676.0 +169 676.0 676.0 +169 676.0 676.0 +17 17.0 17.0 +170 170.0 170.0 +172 344.0 344.0 +172 344.0 344.0 +174 348.0 348.0 +174 348.0 348.0 +175 350.0 350.0 +175 350.0 350.0 +176 352.0 352.0 +176 352.0 352.0 +177 177.0 177.0 +178 178.0 178.0 +179 358.0 358.0 +179 358.0 358.0 +18 36.0 36.0 +18 36.0 36.0 +180 180.0 180.0 +181 181.0 181.0 +183 183.0 183.0 +186 186.0 186.0 +187 561.0 561.0 +187 561.0 561.0 +187 561.0 561.0 +189 189.0 189.0 +19 19.0 19.0 +190 190.0 190.0 +191 382.0 382.0 +191 382.0 382.0 +192 192.0 192.0 +193 579.0 579.0 +193 579.0 579.0 +193 579.0 579.0 +194 194.0 194.0 +195 390.0 390.0 +195 390.0 390.0 +196 196.0 196.0 +197 394.0 394.0 +197 394.0 394.0 +199 597.0 597.0 +199 597.0 597.0 +199 597.0 597.0 +20 20.0 20.0 +200 400.0 400.0 +200 400.0 400.0 +201 201.0 201.0 +202 202.0 202.0 +203 406.0 406.0 +203 406.0 406.0 +205 410.0 410.0 +205 410.0 410.0 +207 414.0 414.0 +207 414.0 414.0 +208 624.0 624.0 +208 624.0 624.0 +208 624.0 624.0 +209 418.0 418.0 +209 418.0 418.0 +213 426.0 426.0 +213 426.0 426.0 +214 214.0 214.0 +216 432.0 432.0 +216 432.0 432.0 +217 434.0 434.0 +217 434.0 434.0 +218 218.0 218.0 +219 438.0 438.0 +219 438.0 438.0 +221 442.0 442.0 +221 442.0 442.0 +222 222.0 222.0 +223 446.0 446.0 +223 446.0 446.0 +224 448.0 448.0 +224 448.0 448.0 +226 226.0 226.0 +228 228.0 228.0 +229 458.0 458.0 +229 458.0 458.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +233 466.0 466.0 +233 466.0 466.0 +235 235.0 235.0 +237 474.0 474.0 +237 474.0 474.0 +238 476.0 476.0 +238 476.0 476.0 +239 478.0 478.0 +239 478.0 478.0 +24 48.0 48.0 +24 48.0 48.0 +241 241.0 241.0 +242 484.0 484.0 +242 484.0 484.0 +244 244.0 244.0 +247 247.0 247.0 +248 248.0 248.0 +249 249.0 249.0 +252 252.0 252.0 +255 510.0 510.0 +255 510.0 510.0 +256 512.0 512.0 +256 512.0 512.0 +257 257.0 257.0 +258 258.0 258.0 +26 52.0 52.0 +26 52.0 52.0 +260 260.0 260.0 +262 262.0 262.0 +263 263.0 263.0 +265 530.0 530.0 +265 530.0 530.0 +266 266.0 266.0 +27 27.0 27.0 +272 544.0 544.0 +272 544.0 544.0 +273 819.0 819.0 +273 819.0 819.0 +273 819.0 819.0 +274 274.0 274.0 +275 275.0 275.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +278 556.0 556.0 +278 556.0 556.0 +28 28.0 28.0 +280 560.0 560.0 +280 560.0 560.0 +281 562.0 562.0 +281 562.0 562.0 +282 564.0 564.0 +282 564.0 564.0 +283 283.0 283.0 +284 284.0 284.0 +285 285.0 285.0 +286 286.0 286.0 +287 287.0 287.0 +288 576.0 576.0 +288 576.0 576.0 +289 289.0 289.0 +291 291.0 291.0 +292 292.0 292.0 +296 296.0 296.0 +298 894.0 894.0 +298 894.0 894.0 +298 894.0 894.0 +30 30.0 30.0 +302 302.0 302.0 +305 305.0 305.0 +306 306.0 306.0 +307 614.0 614.0 +307 614.0 614.0 +308 308.0 308.0 +309 618.0 618.0 +309 618.0 618.0 +310 310.0 310.0 +311 933.0 933.0 +311 933.0 933.0 +311 933.0 933.0 +315 315.0 315.0 +316 948.0 948.0 +316 948.0 948.0 +316 948.0 948.0 +317 634.0 634.0 +317 634.0 634.0 +318 954.0 954.0 +318 954.0 954.0 +318 954.0 954.0 +321 642.0 642.0 +321 642.0 642.0 +322 644.0 644.0 +322 644.0 644.0 +323 323.0 323.0 +325 650.0 650.0 +325 650.0 650.0 +327 981.0 981.0 +327 981.0 981.0 +327 981.0 981.0 +33 33.0 33.0 +331 662.0 662.0 +331 662.0 662.0 +332 332.0 332.0 +333 666.0 666.0 +333 666.0 666.0 +335 335.0 335.0 +336 336.0 336.0 +338 338.0 338.0 +339 339.0 339.0 +34 34.0 34.0 +341 341.0 341.0 +342 684.0 684.0 +342 684.0 684.0 +344 688.0 688.0 +344 688.0 688.0 +345 345.0 345.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +35 105.0 105.0 +35 105.0 105.0 +35 105.0 105.0 +351 351.0 351.0 +353 706.0 706.0 +353 706.0 706.0 +356 356.0 356.0 +360 360.0 360.0 +362 362.0 362.0 +364 364.0 364.0 +365 365.0 365.0 +366 366.0 366.0 +367 734.0 734.0 +367 734.0 734.0 +368 368.0 368.0 +369 1107.0 1107.0 +369 1107.0 1107.0 +369 1107.0 1107.0 +37 74.0 74.0 +37 74.0 74.0 +373 373.0 373.0 +374 374.0 374.0 +375 375.0 375.0 +377 377.0 377.0 +378 378.0 378.0 +379 379.0 379.0 +382 764.0 764.0 +382 764.0 764.0 +384 1152.0 1152.0 +384 1152.0 1152.0 +384 1152.0 1152.0 +386 386.0 386.0 +389 389.0 389.0 +392 392.0 392.0 +393 393.0 393.0 +394 394.0 394.0 +395 790.0 790.0 +395 790.0 790.0 +396 1188.0 1188.0 +396 1188.0 1188.0 +396 1188.0 1188.0 +397 794.0 794.0 +397 794.0 794.0 +399 798.0 798.0 +399 798.0 798.0 +4 4.0 4.0 +400 400.0 400.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +402 402.0 402.0 +403 1209.0 1209.0 +403 1209.0 1209.0 +403 1209.0 1209.0 +404 808.0 808.0 +404 808.0 808.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +407 407.0 407.0 +409 1227.0 1227.0 +409 1227.0 1227.0 +409 1227.0 1227.0 +41 41.0 41.0 +411 411.0 411.0 +413 826.0 826.0 +413 826.0 826.0 +414 828.0 828.0 +414 828.0 828.0 +417 1251.0 1251.0 +417 1251.0 1251.0 +417 1251.0 1251.0 +418 418.0 418.0 +419 419.0 419.0 +42 84.0 84.0 +42 84.0 84.0 +421 421.0 421.0 +424 848.0 848.0 +424 848.0 848.0 +427 427.0 427.0 +429 858.0 858.0 +429 858.0 858.0 +43 43.0 43.0 +430 1290.0 1290.0 +430 1290.0 1290.0 +430 1290.0 1290.0 +431 1293.0 1293.0 +431 1293.0 1293.0 +431 1293.0 1293.0 +432 432.0 432.0 +435 435.0 435.0 +436 436.0 436.0 +437 437.0 437.0 +438 1314.0 1314.0 +438 1314.0 1314.0 +438 1314.0 1314.0 +439 878.0 878.0 +439 878.0 878.0 +44 44.0 44.0 +443 443.0 443.0 +444 444.0 444.0 +446 446.0 446.0 +448 448.0 448.0 +449 449.0 449.0 +452 452.0 452.0 +453 453.0 453.0 +454 1362.0 1362.0 +454 1362.0 1362.0 +454 1362.0 1362.0 +455 455.0 455.0 +457 457.0 457.0 +458 916.0 916.0 +458 916.0 916.0 +459 918.0 918.0 +459 918.0 918.0 +460 460.0 460.0 +462 924.0 924.0 +462 924.0 924.0 +463 926.0 926.0 +463 926.0 926.0 +466 1398.0 1398.0 +466 1398.0 1398.0 +466 1398.0 1398.0 +467 467.0 467.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +47 47.0 47.0 +470 470.0 470.0 +472 472.0 472.0 +475 475.0 475.0 +477 477.0 477.0 +478 956.0 956.0 +478 956.0 956.0 +479 479.0 479.0 +480 1440.0 1440.0 +480 1440.0 1440.0 +480 1440.0 1440.0 +481 481.0 481.0 +482 482.0 482.0 +483 483.0 483.0 +484 484.0 484.0 +485 485.0 485.0 +487 487.0 487.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +490 490.0 490.0 +491 491.0 491.0 +492 984.0 984.0 +492 984.0 984.0 +493 493.0 493.0 +494 494.0 494.0 +495 495.0 495.0 +496 496.0 496.0 +497 497.0 497.0 +498 1494.0 1494.0 +498 1494.0 1494.0 +498 1494.0 1494.0 +5 15.0 15.0 +5 15.0 15.0 +5 15.0 15.0 +51 102.0 102.0 +51 102.0 102.0 +53 53.0 53.0 +54 54.0 54.0 +57 57.0 57.0 +58 116.0 116.0 +58 116.0 116.0 +64 64.0 64.0 +65 65.0 65.0 +66 66.0 66.0 +67 134.0 134.0 +67 134.0 134.0 +69 69.0 69.0 +70 210.0 210.0 +70 210.0 210.0 +70 210.0 210.0 +72 144.0 144.0 +72 144.0 144.0 +74 74.0 74.0 +76 152.0 152.0 +76 152.0 152.0 +77 77.0 77.0 +78 78.0 78.0 +8 8.0 8.0 +80 80.0 80.0 +82 82.0 82.0 +83 166.0 166.0 +83 166.0 166.0 +84 168.0 168.0 +84 168.0 168.0 +85 85.0 85.0 +86 86.0 86.0 +87 87.0 87.0 +9 9.0 9.0 +90 270.0 270.0 +90 270.0 270.0 +90 270.0 270.0 +92 92.0 92.0 +95 190.0 190.0 +95 190.0 190.0 +96 96.0 96.0 +97 194.0 194.0 +97 194.0 194.0 +98 196.0 196.0 +98 196.0 196.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 10.0 +100 200.0 200.0 +100 200.0 200.0 +103 206.0 206.0 +103 206.0 206.0 +104 208.0 208.0 +104 208.0 208.0 +105 105.0 105.0 +11 11.0 11.0 +111 111.0 111.0 +113 226.0 226.0 +113 226.0 226.0 +114 114.0 114.0 +116 116.0 116.0 +118 236.0 236.0 +118 236.0 236.0 +119 357.0 357.0 +119 357.0 357.0 +119 357.0 357.0 +12 24.0 24.0 +12 24.0 24.0 +120 240.0 240.0 +120 240.0 240.0 +125 250.0 250.0 +125 250.0 250.0 +126 126.0 126.0 +128 384.0 384.0 +128 384.0 384.0 +128 384.0 384.0 +129 258.0 258.0 +129 258.0 258.0 +131 131.0 131.0 +133 133.0 133.0 +134 268.0 268.0 +134 268.0 268.0 +136 136.0 136.0 +137 274.0 274.0 +137 274.0 274.0 +138 552.0 552.0 +138 552.0 552.0 +138 552.0 552.0 +138 552.0 552.0 +143 143.0 143.0 +145 145.0 145.0 +146 292.0 292.0 +146 292.0 292.0 +149 298.0 298.0 +149 298.0 298.0 +15 30.0 30.0 +15 30.0 30.0 +150 150.0 150.0 +152 304.0 304.0 +152 304.0 304.0 +153 153.0 153.0 +155 155.0 155.0 +156 156.0 156.0 +157 157.0 157.0 +158 158.0 158.0 +160 160.0 160.0 +162 162.0 162.0 +163 163.0 163.0 +164 328.0 328.0 +164 328.0 328.0 +165 330.0 330.0 +165 330.0 330.0 +166 166.0 166.0 +167 501.0 501.0 +167 501.0 501.0 +167 501.0 501.0 +168 168.0 168.0 +169 676.0 676.0 +169 676.0 676.0 +169 676.0 676.0 +169 676.0 676.0 +17 17.0 17.0 +170 170.0 170.0 +172 344.0 344.0 +172 344.0 344.0 +174 348.0 348.0 +174 348.0 348.0 +175 350.0 350.0 +175 350.0 350.0 +176 352.0 352.0 +176 352.0 352.0 +177 177.0 177.0 +178 178.0 178.0 +179 358.0 358.0 +179 358.0 358.0 +18 36.0 36.0 +18 36.0 36.0 +180 180.0 180.0 +181 181.0 181.0 +183 183.0 183.0 +186 186.0 186.0 +187 561.0 561.0 +187 561.0 561.0 +187 561.0 561.0 +189 189.0 189.0 +19 19.0 19.0 +190 190.0 190.0 +191 382.0 382.0 +191 382.0 382.0 +192 192.0 192.0 +193 579.0 579.0 +193 579.0 579.0 +193 579.0 579.0 +194 194.0 194.0 +195 390.0 390.0 +195 390.0 390.0 +196 196.0 196.0 +197 394.0 394.0 +197 394.0 394.0 +199 597.0 597.0 +199 597.0 597.0 +199 597.0 597.0 +2 2.0 2.0 +20 20.0 20.0 +200 400.0 400.0 +200 400.0 400.0 +201 201.0 201.0 +202 202.0 202.0 +203 406.0 406.0 +203 406.0 406.0 +205 410.0 410.0 +205 410.0 410.0 +207 414.0 414.0 +207 414.0 414.0 +208 624.0 624.0 +208 624.0 624.0 +208 624.0 624.0 +209 418.0 418.0 +209 418.0 418.0 +213 426.0 426.0 +213 426.0 426.0 +214 214.0 214.0 +216 432.0 432.0 +216 432.0 432.0 +217 434.0 434.0 +217 434.0 434.0 +218 218.0 218.0 +219 438.0 438.0 +219 438.0 438.0 +221 442.0 442.0 +221 442.0 442.0 +222 222.0 222.0 +223 446.0 446.0 +223 446.0 446.0 +224 448.0 448.0 +224 448.0 448.0 +226 226.0 226.0 +228 228.0 228.0 +229 458.0 458.0 +229 458.0 458.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +230 1150.0 1150.0 +233 466.0 466.0 +233 466.0 466.0 +235 235.0 235.0 +237 474.0 474.0 +237 474.0 474.0 +238 476.0 476.0 +238 476.0 476.0 +239 478.0 478.0 +239 478.0 478.0 +24 48.0 48.0 +24 48.0 48.0 +241 241.0 241.0 +242 484.0 484.0 +242 484.0 484.0 +244 244.0 244.0 +247 247.0 247.0 +248 248.0 248.0 +249 249.0 249.0 +252 252.0 252.0 +255 510.0 510.0 +255 510.0 510.0 +256 512.0 512.0 +256 512.0 512.0 +257 257.0 257.0 +258 258.0 258.0 +26 52.0 52.0 +26 52.0 52.0 +260 260.0 260.0 +262 262.0 262.0 +263 263.0 263.0 +265 530.0 530.0 +265 530.0 530.0 +266 266.0 266.0 +27 27.0 27.0 +272 544.0 544.0 +272 544.0 544.0 +273 819.0 819.0 +273 819.0 819.0 +273 819.0 819.0 +274 274.0 274.0 +275 275.0 275.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +277 1108.0 1108.0 +278 556.0 556.0 +278 556.0 556.0 +28 28.0 28.0 +280 560.0 560.0 +280 560.0 560.0 +281 562.0 562.0 +281 562.0 562.0 +282 564.0 564.0 +282 564.0 564.0 +283 283.0 283.0 +284 284.0 284.0 +285 285.0 285.0 +286 286.0 286.0 +287 287.0 287.0 +288 576.0 576.0 +288 576.0 576.0 +289 289.0 289.0 +291 291.0 291.0 +292 292.0 292.0 +296 296.0 296.0 +298 894.0 894.0 +298 894.0 894.0 +298 894.0 894.0 +30 30.0 30.0 +302 302.0 302.0 +305 305.0 305.0 +306 306.0 306.0 +307 614.0 614.0 +307 614.0 614.0 +308 308.0 308.0 +309 618.0 618.0 +309 618.0 618.0 +310 310.0 310.0 +311 933.0 933.0 +311 933.0 933.0 +311 933.0 933.0 +315 315.0 315.0 +316 948.0 948.0 +316 948.0 948.0 +316 948.0 948.0 +317 634.0 634.0 +317 634.0 634.0 +318 954.0 954.0 +318 954.0 954.0 +318 954.0 954.0 +321 642.0 642.0 +321 642.0 642.0 +322 644.0 644.0 +322 644.0 644.0 +323 323.0 323.0 +325 650.0 650.0 +325 650.0 650.0 +327 981.0 981.0 +327 981.0 981.0 +327 981.0 981.0 +33 33.0 33.0 +331 662.0 662.0 +331 662.0 662.0 +332 332.0 332.0 +333 666.0 666.0 +333 666.0 666.0 +335 335.0 335.0 +336 336.0 336.0 +338 338.0 338.0 +339 339.0 339.0 +34 34.0 34.0 +341 341.0 341.0 +342 684.0 684.0 +342 684.0 684.0 +344 688.0 688.0 +344 688.0 688.0 +345 345.0 345.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +348 1740.0 1740.0 +35 105.0 105.0 +35 105.0 105.0 +35 105.0 105.0 +351 351.0 351.0 +353 706.0 706.0 +353 706.0 706.0 +356 356.0 356.0 +360 360.0 360.0 +362 362.0 362.0 +364 364.0 364.0 +365 365.0 365.0 +366 366.0 366.0 +367 734.0 734.0 +367 734.0 734.0 +368 368.0 368.0 +369 1107.0 1107.0 +369 1107.0 1107.0 +369 1107.0 1107.0 +37 74.0 74.0 +37 74.0 74.0 +373 373.0 373.0 +374 374.0 374.0 +375 375.0 375.0 +377 377.0 377.0 +378 378.0 378.0 +379 379.0 379.0 +382 764.0 764.0 +382 764.0 764.0 +384 1152.0 1152.0 +384 1152.0 1152.0 +384 1152.0 1152.0 +386 386.0 386.0 +389 389.0 389.0 +392 392.0 392.0 +393 393.0 393.0 +394 394.0 394.0 +395 790.0 790.0 +395 790.0 790.0 +396 1188.0 1188.0 +396 1188.0 1188.0 +396 1188.0 1188.0 +397 794.0 794.0 +397 794.0 794.0 +399 798.0 798.0 +399 798.0 798.0 +4 4.0 4.0 +400 400.0 400.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +401 2005.0 2005.0 +402 402.0 402.0 +403 1209.0 1209.0 +403 1209.0 1209.0 +403 1209.0 1209.0 +404 808.0 808.0 +404 808.0 808.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +406 1624.0 1624.0 +407 407.0 407.0 +409 1227.0 1227.0 +409 1227.0 1227.0 +409 1227.0 1227.0 +41 41.0 41.0 +411 411.0 411.0 +413 826.0 826.0 +413 826.0 826.0 +414 828.0 828.0 +414 828.0 828.0 +417 1251.0 1251.0 +417 1251.0 1251.0 +417 1251.0 1251.0 +418 418.0 418.0 +419 419.0 419.0 +42 84.0 84.0 +42 84.0 84.0 +421 421.0 421.0 +424 848.0 848.0 +424 848.0 848.0 +427 427.0 427.0 +429 858.0 858.0 +429 858.0 858.0 +43 43.0 43.0 +430 1290.0 1290.0 +430 1290.0 1290.0 +430 1290.0 1290.0 +431 1293.0 1293.0 +431 1293.0 1293.0 +431 1293.0 1293.0 +432 432.0 432.0 +435 435.0 435.0 +436 436.0 436.0 +437 437.0 437.0 +438 1314.0 1314.0 +438 1314.0 1314.0 +438 1314.0 1314.0 +439 878.0 878.0 +439 878.0 878.0 +44 44.0 44.0 +443 443.0 443.0 +444 444.0 444.0 +446 446.0 446.0 +448 448.0 448.0 +449 449.0 449.0 +452 452.0 452.0 +453 453.0 453.0 +454 1362.0 1362.0 +454 1362.0 1362.0 +454 1362.0 1362.0 +455 455.0 455.0 +457 457.0 457.0 +458 916.0 916.0 +458 916.0 916.0 +459 918.0 918.0 +459 918.0 918.0 +460 460.0 460.0 +462 924.0 924.0 +462 924.0 924.0 +463 926.0 926.0 +463 926.0 926.0 +466 1398.0 1398.0 +466 1398.0 1398.0 +466 1398.0 1398.0 +467 467.0 467.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +468 1872.0 1872.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +469 2345.0 2345.0 +47 47.0 47.0 +470 470.0 470.0 +472 472.0 472.0 +475 475.0 475.0 +477 477.0 477.0 +478 956.0 956.0 +478 956.0 956.0 +479 479.0 479.0 +480 1440.0 1440.0 +480 1440.0 1440.0 +480 1440.0 1440.0 +481 481.0 481.0 +482 482.0 482.0 +483 483.0 483.0 +484 484.0 484.0 +485 485.0 485.0 +487 487.0 487.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +489 1956.0 1956.0 +490 490.0 490.0 +491 491.0 491.0 +492 984.0 984.0 +492 984.0 984.0 +493 493.0 493.0 +494 494.0 494.0 +495 495.0 495.0 +496 496.0 496.0 +497 497.0 497.0 +498 1494.0 1494.0 +498 1494.0 1494.0 +498 1494.0 1494.0 +5 15.0 15.0 +5 15.0 15.0 +5 15.0 15.0 +51 102.0 102.0 +51 102.0 102.0 +53 53.0 53.0 +54 54.0 54.0 +57 57.0 57.0 +58 116.0 116.0 +58 116.0 116.0 +64 64.0 64.0 +65 65.0 65.0 +66 66.0 66.0 +67 134.0 134.0 +67 134.0 134.0 +69 69.0 69.0 +70 210.0 210.0 +70 210.0 210.0 +70 210.0 210.0 +72 144.0 144.0 +72 144.0 144.0 +74 74.0 74.0 +76 152.0 152.0 +76 152.0 152.0 +77 77.0 77.0 +78 78.0 78.0 +8 8.0 8.0 +80 80.0 80.0 +82 82.0 82.0 +83 166.0 166.0 +83 166.0 166.0 +84 168.0 168.0 +84 168.0 168.0 +85 85.0 85.0 +86 86.0 86.0 +87 87.0 87.0 +9 9.0 9.0 +90 270.0 270.0 +90 270.0 270.0 +90 270.0 270.0 +92 92.0 92.0 +95 190.0 190.0 +95 190.0 190.0 +96 96.0 96.0 +97 194.0 194.0 +97 194.0 194.0 +98 196.0 196.0 +98 196.0 196.0 +PREHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(key) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +2 0.0 0.0 +2 0.0 0.0 +2 0.0 0.0 +12 10.0 10.0 +102 200.0 200.0 +102 200.0 200.0 +105 206.0 206.0 +105 206.0 206.0 +106 208.0 208.0 +106 208.0 208.0 +107 105.0 105.0 +13 11.0 11.0 +113 111.0 111.0 +115 226.0 226.0 +115 226.0 226.0 +116 114.0 114.0 +118 116.0 116.0 +120 236.0 236.0 +120 236.0 236.0 +121 357.0 357.0 +121 357.0 357.0 +121 357.0 357.0 +14 24.0 24.0 +14 24.0 24.0 +122 240.0 240.0 +122 240.0 240.0 +127 250.0 250.0 +127 250.0 250.0 +128 126.0 126.0 +130 384.0 384.0 +130 384.0 384.0 +130 384.0 384.0 +131 258.0 258.0 +131 258.0 258.0 +133 131.0 131.0 +135 133.0 133.0 +136 268.0 268.0 +136 268.0 268.0 +138 136.0 136.0 +139 274.0 274.0 +139 274.0 274.0 +140 552.0 552.0 +140 552.0 552.0 +140 552.0 552.0 +140 552.0 552.0 +145 143.0 143.0 +147 145.0 145.0 +148 292.0 292.0 +148 292.0 292.0 +151 298.0 298.0 +151 298.0 298.0 +17 30.0 30.0 +17 30.0 30.0 +152 150.0 150.0 +154 304.0 304.0 +154 304.0 304.0 +155 153.0 153.0 +157 155.0 155.0 +158 156.0 156.0 +159 157.0 157.0 +160 158.0 158.0 +162 160.0 160.0 +164 162.0 162.0 +165 163.0 163.0 +166 328.0 328.0 +166 328.0 328.0 +167 330.0 330.0 +167 330.0 330.0 +168 166.0 166.0 +169 501.0 501.0 +169 501.0 501.0 +169 501.0 501.0 +170 168.0 168.0 +171 676.0 676.0 +171 676.0 676.0 +171 676.0 676.0 +171 676.0 676.0 +19 17.0 17.0 +172 170.0 170.0 +174 344.0 344.0 +174 344.0 344.0 +176 348.0 348.0 +176 348.0 348.0 +177 350.0 350.0 +177 350.0 350.0 +178 352.0 352.0 +178 352.0 352.0 +179 177.0 177.0 +180 178.0 178.0 +181 358.0 358.0 +181 358.0 358.0 +20 36.0 36.0 +20 36.0 36.0 +182 180.0 180.0 +183 181.0 181.0 +185 183.0 183.0 +188 186.0 186.0 +189 561.0 561.0 +189 561.0 561.0 +189 561.0 561.0 +191 189.0 189.0 +21 19.0 19.0 +192 190.0 190.0 +193 382.0 382.0 +193 382.0 382.0 +194 192.0 192.0 +195 579.0 579.0 +195 579.0 579.0 +195 579.0 579.0 +196 194.0 194.0 +197 390.0 390.0 +197 390.0 390.0 +198 196.0 196.0 +199 394.0 394.0 +199 394.0 394.0 +201 597.0 597.0 +201 597.0 597.0 +201 597.0 597.0 +4 2.0 2.0 +22 20.0 20.0 +202 400.0 400.0 +202 400.0 400.0 +203 201.0 201.0 +204 202.0 202.0 +205 406.0 406.0 +205 406.0 406.0 +207 410.0 410.0 +207 410.0 410.0 +209 414.0 414.0 +209 414.0 414.0 +210 624.0 624.0 +210 624.0 624.0 +210 624.0 624.0 +211 418.0 418.0 +211 418.0 418.0 +215 426.0 426.0 +215 426.0 426.0 +216 214.0 214.0 +218 432.0 432.0 +218 432.0 432.0 +219 434.0 434.0 +219 434.0 434.0 +220 218.0 218.0 +221 438.0 438.0 +221 438.0 438.0 +223 442.0 442.0 +223 442.0 442.0 +224 222.0 222.0 +225 446.0 446.0 +225 446.0 446.0 +226 448.0 448.0 +226 448.0 448.0 +228 226.0 226.0 +230 228.0 228.0 +231 458.0 458.0 +231 458.0 458.0 +232 1150.0 1150.0 +232 1150.0 1150.0 +232 1150.0 1150.0 +232 1150.0 1150.0 +232 1150.0 1150.0 +235 466.0 466.0 +235 466.0 466.0 +237 235.0 235.0 +239 474.0 474.0 +239 474.0 474.0 +240 476.0 476.0 +240 476.0 476.0 +241 478.0 478.0 +241 478.0 478.0 +26 48.0 48.0 +26 48.0 48.0 +243 241.0 241.0 +244 484.0 484.0 +244 484.0 484.0 +246 244.0 244.0 +249 247.0 247.0 +250 248.0 248.0 +251 249.0 249.0 +254 252.0 252.0 +257 510.0 510.0 +257 510.0 510.0 +258 512.0 512.0 +258 512.0 512.0 +259 257.0 257.0 +260 258.0 258.0 +28 52.0 52.0 +28 52.0 52.0 +262 260.0 260.0 +264 262.0 262.0 +265 263.0 263.0 +267 530.0 530.0 +267 530.0 530.0 +268 266.0 266.0 +29 27.0 27.0 +274 544.0 544.0 +274 544.0 544.0 +275 819.0 819.0 +275 819.0 819.0 +275 819.0 819.0 +276 274.0 274.0 +277 275.0 275.0 +279 1108.0 1108.0 +279 1108.0 1108.0 +279 1108.0 1108.0 +279 1108.0 1108.0 +280 556.0 556.0 +280 556.0 556.0 +30 28.0 28.0 +282 560.0 560.0 +282 560.0 560.0 +283 562.0 562.0 +283 562.0 562.0 +284 564.0 564.0 +284 564.0 564.0 +285 283.0 283.0 +286 284.0 284.0 +287 285.0 285.0 +288 286.0 286.0 +289 287.0 287.0 +290 576.0 576.0 +290 576.0 576.0 +291 289.0 289.0 +293 291.0 291.0 +294 292.0 292.0 +298 296.0 296.0 +300 894.0 894.0 +300 894.0 894.0 +300 894.0 894.0 +32 30.0 30.0 +304 302.0 302.0 +307 305.0 305.0 +308 306.0 306.0 +309 614.0 614.0 +309 614.0 614.0 +310 308.0 308.0 +311 618.0 618.0 +311 618.0 618.0 +312 310.0 310.0 +313 933.0 933.0 +313 933.0 933.0 +313 933.0 933.0 +317 315.0 315.0 +318 948.0 948.0 +318 948.0 948.0 +318 948.0 948.0 +319 634.0 634.0 +319 634.0 634.0 +320 954.0 954.0 +320 954.0 954.0 +320 954.0 954.0 +323 642.0 642.0 +323 642.0 642.0 +324 644.0 644.0 +324 644.0 644.0 +325 323.0 323.0 +327 650.0 650.0 +327 650.0 650.0 +329 981.0 981.0 +329 981.0 981.0 +329 981.0 981.0 +35 33.0 33.0 +333 662.0 662.0 +333 662.0 662.0 +334 332.0 332.0 +335 666.0 666.0 +335 666.0 666.0 +337 335.0 335.0 +338 336.0 336.0 +340 338.0 338.0 +341 339.0 339.0 +36 34.0 34.0 +343 341.0 341.0 +344 684.0 684.0 +344 684.0 684.0 +346 688.0 688.0 +346 688.0 688.0 +347 345.0 345.0 +350 1740.0 1740.0 +350 1740.0 1740.0 +350 1740.0 1740.0 +350 1740.0 1740.0 +350 1740.0 1740.0 +37 105.0 105.0 +37 105.0 105.0 +37 105.0 105.0 +353 351.0 351.0 +355 706.0 706.0 +355 706.0 706.0 +358 356.0 356.0 +362 360.0 360.0 +364 362.0 362.0 +366 364.0 364.0 +367 365.0 365.0 +368 366.0 366.0 +369 734.0 734.0 +369 734.0 734.0 +370 368.0 368.0 +371 1107.0 1107.0 +371 1107.0 1107.0 +371 1107.0 1107.0 +39 74.0 74.0 +39 74.0 74.0 +375 373.0 373.0 +376 374.0 374.0 +377 375.0 375.0 +379 377.0 377.0 +380 378.0 378.0 +381 379.0 379.0 +384 764.0 764.0 +384 764.0 764.0 +386 1152.0 1152.0 +386 1152.0 1152.0 +386 1152.0 1152.0 +388 386.0 386.0 +391 389.0 389.0 +394 392.0 392.0 +395 393.0 393.0 +396 394.0 394.0 +397 790.0 790.0 +397 790.0 790.0 +398 1188.0 1188.0 +398 1188.0 1188.0 +398 1188.0 1188.0 +399 794.0 794.0 +399 794.0 794.0 +401 798.0 798.0 +401 798.0 798.0 +6 4.0 4.0 +402 400.0 400.0 +403 2005.0 2005.0 +403 2005.0 2005.0 +403 2005.0 2005.0 +403 2005.0 2005.0 +403 2005.0 2005.0 +404 402.0 402.0 +405 1209.0 1209.0 +405 1209.0 1209.0 +405 1209.0 1209.0 +406 808.0 808.0 +406 808.0 808.0 +408 1624.0 1624.0 +408 1624.0 1624.0 +408 1624.0 1624.0 +408 1624.0 1624.0 +409 407.0 407.0 +411 1227.0 1227.0 +411 1227.0 1227.0 +411 1227.0 1227.0 +43 41.0 41.0 +413 411.0 411.0 +415 826.0 826.0 +415 826.0 826.0 +416 828.0 828.0 +416 828.0 828.0 +419 1251.0 1251.0 +419 1251.0 1251.0 +419 1251.0 1251.0 +420 418.0 418.0 +421 419.0 419.0 +44 84.0 84.0 +44 84.0 84.0 +423 421.0 421.0 +426 848.0 848.0 +426 848.0 848.0 +429 427.0 427.0 +431 858.0 858.0 +431 858.0 858.0 +45 43.0 43.0 +432 1290.0 1290.0 +432 1290.0 1290.0 +432 1290.0 1290.0 +433 1293.0 1293.0 +433 1293.0 1293.0 +433 1293.0 1293.0 +434 432.0 432.0 +437 435.0 435.0 +438 436.0 436.0 +439 437.0 437.0 +440 1314.0 1314.0 +440 1314.0 1314.0 +440 1314.0 1314.0 +441 878.0 878.0 +441 878.0 878.0 +46 44.0 44.0 +445 443.0 443.0 +446 444.0 444.0 +448 446.0 446.0 +450 448.0 448.0 +451 449.0 449.0 +454 452.0 452.0 +455 453.0 453.0 +456 1362.0 1362.0 +456 1362.0 1362.0 +456 1362.0 1362.0 +457 455.0 455.0 +459 457.0 457.0 +460 916.0 916.0 +460 916.0 916.0 +461 918.0 918.0 +461 918.0 918.0 +462 460.0 460.0 +464 924.0 924.0 +464 924.0 924.0 +465 926.0 926.0 +465 926.0 926.0 +468 1398.0 1398.0 +468 1398.0 1398.0 +468 1398.0 1398.0 +469 467.0 467.0 +470 1872.0 1872.0 +470 1872.0 1872.0 +470 1872.0 1872.0 +470 1872.0 1872.0 +471 2345.0 2345.0 +471 2345.0 2345.0 +471 2345.0 2345.0 +471 2345.0 2345.0 +471 2345.0 2345.0 +49 47.0 47.0 +472 470.0 470.0 +474 472.0 472.0 +477 475.0 475.0 +479 477.0 477.0 +480 956.0 956.0 +480 956.0 956.0 +481 479.0 479.0 +482 1440.0 1440.0 +482 1440.0 1440.0 +482 1440.0 1440.0 +483 481.0 481.0 +484 482.0 482.0 +485 483.0 483.0 +486 484.0 484.0 +487 485.0 485.0 +489 487.0 487.0 +491 1956.0 1956.0 +491 1956.0 1956.0 +491 1956.0 1956.0 +491 1956.0 1956.0 +492 490.0 490.0 +493 491.0 491.0 +494 984.0 984.0 +494 984.0 984.0 +495 493.0 493.0 +496 494.0 494.0 +497 495.0 495.0 +498 496.0 496.0 +499 497.0 497.0 +500 1494.0 1494.0 +500 1494.0 1494.0 +500 1494.0 1494.0 +7 15.0 15.0 +7 15.0 15.0 +7 15.0 15.0 +53 102.0 102.0 +53 102.0 102.0 +55 53.0 53.0 +56 54.0 54.0 +59 57.0 57.0 +60 116.0 116.0 +60 116.0 116.0 +66 64.0 64.0 +67 65.0 65.0 +68 66.0 66.0 +69 134.0 134.0 +69 134.0 134.0 +71 69.0 69.0 +72 210.0 210.0 +72 210.0 210.0 +72 210.0 210.0 +74 144.0 144.0 +74 144.0 144.0 +76 74.0 74.0 +78 152.0 152.0 +78 152.0 152.0 +79 77.0 77.0 +80 78.0 78.0 +10 8.0 8.0 +82 80.0 80.0 +84 82.0 82.0 +85 166.0 166.0 +85 166.0 166.0 +86 168.0 168.0 +86 168.0 168.0 +87 85.0 85.0 +88 86.0 86.0 +89 87.0 87.0 +11 9.0 9.0 +92 270.0 270.0 +92 270.0 270.0 +92 270.0 270.0 +94 92.0 92.0 +97 190.0 190.0 +97 190.0 190.0 +98 96.0 96.0 +99 194.0 194.0 +99 194.0 194.0 +100 196.0 196.0 +100 196.0 196.0 +PREHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF has different args +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- Test PPD through Windowing where predicate is a subset of partition keys, multiple windows are involved and UDAF has different args +select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +20 20.0 0.0 +200 400.0 0.0 +200 400.0 0.0 +201 201.0 0.0 +202 202.0 0.0 +203 406.0 0.0 +203 406.0 0.0 +205 410.0 0.0 +205 410.0 0.0 +207 414.0 0.0 +207 414.0 0.0 +208 624.0 0.0 +208 624.0 0.0 +208 624.0 0.0 +209 418.0 0.0 +209 418.0 0.0 +213 426.0 0.0 +213 426.0 0.0 +214 214.0 0.0 +216 432.0 0.0 +216 432.0 0.0 +217 434.0 0.0 +217 434.0 0.0 +218 218.0 0.0 +219 438.0 0.0 +219 438.0 0.0 +221 442.0 0.0 +221 442.0 0.0 +222 222.0 0.0 +223 446.0 0.0 +223 446.0 0.0 +224 448.0 0.0 +224 448.0 0.0 +226 226.0 0.0 +228 228.0 0.0 +229 458.0 0.0 +229 458.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +233 466.0 0.0 +233 466.0 0.0 +235 235.0 0.0 +237 474.0 0.0 +237 474.0 0.0 +238 476.0 0.0 +238 476.0 0.0 +239 478.0 0.0 +239 478.0 0.0 +24 48.0 0.0 +24 48.0 0.0 +241 241.0 0.0 +242 484.0 0.0 +242 484.0 0.0 +244 244.0 0.0 +247 247.0 0.0 +248 248.0 0.0 +249 249.0 0.0 +252 252.0 0.0 +255 510.0 0.0 +255 510.0 0.0 +256 512.0 0.0 +256 512.0 0.0 +257 257.0 0.0 +258 258.0 0.0 +26 52.0 0.0 +26 52.0 0.0 +260 260.0 0.0 +262 262.0 0.0 +263 263.0 0.0 +265 530.0 0.0 +265 530.0 0.0 +266 266.0 0.0 +27 27.0 0.0 +272 544.0 0.0 +272 544.0 0.0 +273 819.0 0.0 +273 819.0 0.0 +273 819.0 0.0 +274 274.0 0.0 +275 275.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +278 556.0 0.0 +278 556.0 0.0 +28 28.0 0.0 +280 560.0 0.0 +280 560.0 0.0 +281 562.0 0.0 +281 562.0 0.0 +282 564.0 0.0 +282 564.0 0.0 +283 283.0 0.0 +284 284.0 0.0 +285 285.0 0.0 +286 286.0 0.0 +287 287.0 0.0 +288 576.0 0.0 +288 576.0 0.0 +289 289.0 0.0 +291 291.0 0.0 +292 292.0 0.0 +296 296.0 0.0 +298 894.0 0.0 +298 894.0 0.0 +298 894.0 0.0 +30 30.0 0.0 +302 302.0 0.0 +305 305.0 0.0 +306 306.0 0.0 +307 614.0 0.0 +307 614.0 0.0 +308 308.0 0.0 +309 618.0 0.0 +309 618.0 0.0 +310 310.0 0.0 +311 933.0 0.0 +311 933.0 0.0 +311 933.0 0.0 +315 315.0 0.0 +316 948.0 0.0 +316 948.0 0.0 +316 948.0 0.0 +317 634.0 0.0 +317 634.0 0.0 +318 954.0 0.0 +318 954.0 0.0 +318 954.0 0.0 +321 642.0 0.0 +321 642.0 0.0 +322 644.0 0.0 +322 644.0 0.0 +323 323.0 0.0 +325 650.0 0.0 +325 650.0 0.0 +327 981.0 0.0 +327 981.0 0.0 +327 981.0 0.0 +33 33.0 0.0 +331 662.0 0.0 +331 662.0 0.0 +332 332.0 0.0 +333 666.0 0.0 +333 666.0 0.0 +335 335.0 0.0 +336 336.0 0.0 +338 338.0 0.0 +339 339.0 0.0 +34 34.0 0.0 +341 341.0 0.0 +342 684.0 0.0 +342 684.0 0.0 +344 688.0 0.0 +344 688.0 0.0 +345 345.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +35 105.0 0.0 +35 105.0 0.0 +35 105.0 0.0 +351 351.0 0.0 +353 706.0 0.0 +353 706.0 0.0 +356 356.0 0.0 +360 360.0 0.0 +362 362.0 0.0 +364 364.0 0.0 +365 365.0 0.0 +366 366.0 0.0 +367 734.0 0.0 +367 734.0 0.0 +368 368.0 0.0 +369 1107.0 0.0 +369 1107.0 0.0 +369 1107.0 0.0 +37 74.0 0.0 +37 74.0 0.0 +373 373.0 0.0 +374 374.0 0.0 +375 375.0 0.0 +377 377.0 0.0 +378 378.0 0.0 +379 379.0 0.0 +382 764.0 0.0 +382 764.0 0.0 +384 1152.0 0.0 +384 1152.0 0.0 +384 1152.0 0.0 +386 386.0 0.0 +389 389.0 0.0 +392 392.0 0.0 +393 393.0 0.0 +394 394.0 0.0 +395 790.0 0.0 +395 790.0 0.0 +396 1188.0 0.0 +396 1188.0 0.0 +396 1188.0 0.0 +397 794.0 0.0 +397 794.0 0.0 +399 798.0 0.0 +399 798.0 0.0 +4 4.0 0.0 +400 400.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +402 402.0 0.0 +403 1209.0 0.0 +403 1209.0 0.0 +403 1209.0 0.0 +404 808.0 0.0 +404 808.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +407 407.0 0.0 +409 1227.0 0.0 +409 1227.0 0.0 +409 1227.0 0.0 +41 41.0 0.0 +411 411.0 0.0 +413 826.0 0.0 +413 826.0 0.0 +414 828.0 0.0 +414 828.0 0.0 +417 1251.0 0.0 +417 1251.0 0.0 +417 1251.0 0.0 +418 418.0 0.0 +419 419.0 0.0 +42 84.0 0.0 +42 84.0 0.0 +421 421.0 0.0 +424 848.0 0.0 +424 848.0 0.0 +427 427.0 0.0 +429 858.0 0.0 +429 858.0 0.0 +43 43.0 0.0 +430 1290.0 0.0 +430 1290.0 0.0 +430 1290.0 0.0 +431 1293.0 0.0 +431 1293.0 0.0 +431 1293.0 0.0 +432 432.0 0.0 +435 435.0 0.0 +436 436.0 0.0 +437 437.0 0.0 +438 1314.0 0.0 +438 1314.0 0.0 +438 1314.0 0.0 +439 878.0 0.0 +439 878.0 0.0 +44 44.0 0.0 +443 443.0 0.0 +444 444.0 0.0 +446 446.0 0.0 +448 448.0 0.0 +449 449.0 0.0 +452 452.0 0.0 +453 453.0 0.0 +454 1362.0 0.0 +454 1362.0 0.0 +454 1362.0 0.0 +455 455.0 0.0 +457 457.0 0.0 +458 916.0 0.0 +458 916.0 0.0 +459 918.0 0.0 +459 918.0 0.0 +460 460.0 0.0 +462 924.0 0.0 +462 924.0 0.0 +463 926.0 0.0 +463 926.0 0.0 +466 1398.0 0.0 +466 1398.0 0.0 +466 1398.0 0.0 +467 467.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +47 47.0 0.0 +470 470.0 0.0 +472 472.0 0.0 +475 475.0 0.0 +477 477.0 0.0 +478 956.0 0.0 +478 956.0 0.0 +479 479.0 0.0 +480 1440.0 0.0 +480 1440.0 0.0 +480 1440.0 0.0 +481 481.0 0.0 +482 482.0 0.0 +483 483.0 0.0 +484 484.0 0.0 +485 485.0 0.0 +487 487.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +490 490.0 0.0 +491 491.0 0.0 +492 984.0 0.0 +492 984.0 0.0 +493 493.0 0.0 +494 494.0 0.0 +495 495.0 0.0 +496 496.0 0.0 +497 497.0 0.0 +498 1494.0 0.0 +498 1494.0 0.0 +498 1494.0 0.0 +5 15.0 0.0 +5 15.0 0.0 +5 15.0 0.0 +51 102.0 0.0 +51 102.0 0.0 +53 53.0 0.0 +54 54.0 0.0 +57 57.0 0.0 +58 116.0 0.0 +58 116.0 0.0 +64 64.0 0.0 +65 65.0 0.0 +66 66.0 0.0 +67 134.0 0.0 +67 134.0 0.0 +69 69.0 0.0 +70 210.0 0.0 +70 210.0 0.0 +70 210.0 0.0 +72 144.0 0.0 +72 144.0 0.0 +74 74.0 0.0 +76 152.0 0.0 +76 152.0 0.0 +77 77.0 0.0 +78 78.0 0.0 +8 8.0 0.0 +80 80.0 0.0 +82 82.0 0.0 +83 166.0 0.0 +83 166.0 0.0 +84 168.0 0.0 +84 168.0 0.0 +85 85.0 0.0 +86 86.0 0.0 +87 87.0 0.0 +9 9.0 0.0 +90 270.0 0.0 +90 270.0 0.0 +90 270.0 0.0 +92 92.0 0.0 +95 190.0 0.0 +95 190.0 0.0 +96 96.0 0.0 +97 194.0 0.0 +97 194.0 0.0 +98 196.0 0.0 +98 196.0 0.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where key > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 0.0 +100 200.0 0.0 +100 200.0 0.0 +103 206.0 0.0 +103 206.0 0.0 +104 208.0 0.0 +104 208.0 0.0 +105 105.0 0.0 +11 11.0 0.0 +111 111.0 0.0 +113 226.0 0.0 +113 226.0 0.0 +114 114.0 0.0 +116 116.0 0.0 +118 236.0 0.0 +118 236.0 0.0 +119 357.0 0.0 +119 357.0 0.0 +119 357.0 0.0 +12 24.0 0.0 +12 24.0 0.0 +120 240.0 0.0 +120 240.0 0.0 +125 250.0 0.0 +125 250.0 0.0 +126 126.0 0.0 +128 384.0 0.0 +128 384.0 0.0 +128 384.0 0.0 +129 258.0 0.0 +129 258.0 0.0 +131 131.0 0.0 +133 133.0 0.0 +134 268.0 0.0 +134 268.0 0.0 +136 136.0 0.0 +137 274.0 0.0 +137 274.0 0.0 +138 552.0 0.0 +138 552.0 0.0 +138 552.0 0.0 +138 552.0 0.0 +143 143.0 0.0 +145 145.0 0.0 +146 292.0 0.0 +146 292.0 0.0 +149 298.0 0.0 +149 298.0 0.0 +15 30.0 0.0 +15 30.0 0.0 +150 150.0 0.0 +152 304.0 0.0 +152 304.0 0.0 +153 153.0 0.0 +155 155.0 0.0 +156 156.0 0.0 +157 157.0 0.0 +158 158.0 0.0 +160 160.0 0.0 +162 162.0 0.0 +163 163.0 0.0 +164 328.0 0.0 +164 328.0 0.0 +165 330.0 0.0 +165 330.0 0.0 +166 166.0 0.0 +167 501.0 0.0 +167 501.0 0.0 +167 501.0 0.0 +168 168.0 0.0 +169 676.0 0.0 +169 676.0 0.0 +169 676.0 0.0 +169 676.0 0.0 +17 17.0 0.0 +170 170.0 0.0 +172 344.0 0.0 +172 344.0 0.0 +174 348.0 0.0 +174 348.0 0.0 +175 350.0 0.0 +175 350.0 0.0 +176 352.0 0.0 +176 352.0 0.0 +177 177.0 0.0 +178 178.0 0.0 +179 358.0 0.0 +179 358.0 0.0 +18 36.0 0.0 +18 36.0 0.0 +180 180.0 0.0 +181 181.0 0.0 +183 183.0 0.0 +186 186.0 0.0 +187 561.0 0.0 +187 561.0 0.0 +187 561.0 0.0 +189 189.0 0.0 +19 19.0 0.0 +190 190.0 0.0 +191 382.0 0.0 +191 382.0 0.0 +192 192.0 0.0 +193 579.0 0.0 +193 579.0 0.0 +193 579.0 0.0 +194 194.0 0.0 +195 390.0 0.0 +195 390.0 0.0 +196 196.0 0.0 +197 394.0 0.0 +197 394.0 0.0 +199 597.0 0.0 +199 597.0 0.0 +199 597.0 0.0 +20 20.0 0.0 +200 400.0 0.0 +200 400.0 0.0 +201 201.0 0.0 +202 202.0 0.0 +203 406.0 0.0 +203 406.0 0.0 +205 410.0 0.0 +205 410.0 0.0 +207 414.0 0.0 +207 414.0 0.0 +208 624.0 0.0 +208 624.0 0.0 +208 624.0 0.0 +209 418.0 0.0 +209 418.0 0.0 +213 426.0 0.0 +213 426.0 0.0 +214 214.0 0.0 +216 432.0 0.0 +216 432.0 0.0 +217 434.0 0.0 +217 434.0 0.0 +218 218.0 0.0 +219 438.0 0.0 +219 438.0 0.0 +221 442.0 0.0 +221 442.0 0.0 +222 222.0 0.0 +223 446.0 0.0 +223 446.0 0.0 +224 448.0 0.0 +224 448.0 0.0 +226 226.0 0.0 +228 228.0 0.0 +229 458.0 0.0 +229 458.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +233 466.0 0.0 +233 466.0 0.0 +235 235.0 0.0 +237 474.0 0.0 +237 474.0 0.0 +238 476.0 0.0 +238 476.0 0.0 +239 478.0 0.0 +239 478.0 0.0 +24 48.0 0.0 +24 48.0 0.0 +241 241.0 0.0 +242 484.0 0.0 +242 484.0 0.0 +244 244.0 0.0 +247 247.0 0.0 +248 248.0 0.0 +249 249.0 0.0 +252 252.0 0.0 +255 510.0 0.0 +255 510.0 0.0 +256 512.0 0.0 +256 512.0 0.0 +257 257.0 0.0 +258 258.0 0.0 +26 52.0 0.0 +26 52.0 0.0 +260 260.0 0.0 +262 262.0 0.0 +263 263.0 0.0 +265 530.0 0.0 +265 530.0 0.0 +266 266.0 0.0 +27 27.0 0.0 +272 544.0 0.0 +272 544.0 0.0 +273 819.0 0.0 +273 819.0 0.0 +273 819.0 0.0 +274 274.0 0.0 +275 275.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +278 556.0 0.0 +278 556.0 0.0 +28 28.0 0.0 +280 560.0 0.0 +280 560.0 0.0 +281 562.0 0.0 +281 562.0 0.0 +282 564.0 0.0 +282 564.0 0.0 +283 283.0 0.0 +284 284.0 0.0 +285 285.0 0.0 +286 286.0 0.0 +287 287.0 0.0 +288 576.0 0.0 +288 576.0 0.0 +289 289.0 0.0 +291 291.0 0.0 +292 292.0 0.0 +296 296.0 0.0 +298 894.0 0.0 +298 894.0 0.0 +298 894.0 0.0 +30 30.0 0.0 +302 302.0 0.0 +305 305.0 0.0 +306 306.0 0.0 +307 614.0 0.0 +307 614.0 0.0 +308 308.0 0.0 +309 618.0 0.0 +309 618.0 0.0 +310 310.0 0.0 +311 933.0 0.0 +311 933.0 0.0 +311 933.0 0.0 +315 315.0 0.0 +316 948.0 0.0 +316 948.0 0.0 +316 948.0 0.0 +317 634.0 0.0 +317 634.0 0.0 +318 954.0 0.0 +318 954.0 0.0 +318 954.0 0.0 +321 642.0 0.0 +321 642.0 0.0 +322 644.0 0.0 +322 644.0 0.0 +323 323.0 0.0 +325 650.0 0.0 +325 650.0 0.0 +327 981.0 0.0 +327 981.0 0.0 +327 981.0 0.0 +33 33.0 0.0 +331 662.0 0.0 +331 662.0 0.0 +332 332.0 0.0 +333 666.0 0.0 +333 666.0 0.0 +335 335.0 0.0 +336 336.0 0.0 +338 338.0 0.0 +339 339.0 0.0 +34 34.0 0.0 +341 341.0 0.0 +342 684.0 0.0 +342 684.0 0.0 +344 688.0 0.0 +344 688.0 0.0 +345 345.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +35 105.0 0.0 +35 105.0 0.0 +35 105.0 0.0 +351 351.0 0.0 +353 706.0 0.0 +353 706.0 0.0 +356 356.0 0.0 +360 360.0 0.0 +362 362.0 0.0 +364 364.0 0.0 +365 365.0 0.0 +366 366.0 0.0 +367 734.0 0.0 +367 734.0 0.0 +368 368.0 0.0 +369 1107.0 0.0 +369 1107.0 0.0 +369 1107.0 0.0 +37 74.0 0.0 +37 74.0 0.0 +373 373.0 0.0 +374 374.0 0.0 +375 375.0 0.0 +377 377.0 0.0 +378 378.0 0.0 +379 379.0 0.0 +382 764.0 0.0 +382 764.0 0.0 +384 1152.0 0.0 +384 1152.0 0.0 +384 1152.0 0.0 +386 386.0 0.0 +389 389.0 0.0 +392 392.0 0.0 +393 393.0 0.0 +394 394.0 0.0 +395 790.0 0.0 +395 790.0 0.0 +396 1188.0 0.0 +396 1188.0 0.0 +396 1188.0 0.0 +397 794.0 0.0 +397 794.0 0.0 +399 798.0 0.0 +399 798.0 0.0 +4 4.0 0.0 +400 400.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +402 402.0 0.0 +403 1209.0 0.0 +403 1209.0 0.0 +403 1209.0 0.0 +404 808.0 0.0 +404 808.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +407 407.0 0.0 +409 1227.0 0.0 +409 1227.0 0.0 +409 1227.0 0.0 +41 41.0 0.0 +411 411.0 0.0 +413 826.0 0.0 +413 826.0 0.0 +414 828.0 0.0 +414 828.0 0.0 +417 1251.0 0.0 +417 1251.0 0.0 +417 1251.0 0.0 +418 418.0 0.0 +419 419.0 0.0 +42 84.0 0.0 +42 84.0 0.0 +421 421.0 0.0 +424 848.0 0.0 +424 848.0 0.0 +427 427.0 0.0 +429 858.0 0.0 +429 858.0 0.0 +43 43.0 0.0 +430 1290.0 0.0 +430 1290.0 0.0 +430 1290.0 0.0 +431 1293.0 0.0 +431 1293.0 0.0 +431 1293.0 0.0 +432 432.0 0.0 +435 435.0 0.0 +436 436.0 0.0 +437 437.0 0.0 +438 1314.0 0.0 +438 1314.0 0.0 +438 1314.0 0.0 +439 878.0 0.0 +439 878.0 0.0 +44 44.0 0.0 +443 443.0 0.0 +444 444.0 0.0 +446 446.0 0.0 +448 448.0 0.0 +449 449.0 0.0 +452 452.0 0.0 +453 453.0 0.0 +454 1362.0 0.0 +454 1362.0 0.0 +454 1362.0 0.0 +455 455.0 0.0 +457 457.0 0.0 +458 916.0 0.0 +458 916.0 0.0 +459 918.0 0.0 +459 918.0 0.0 +460 460.0 0.0 +462 924.0 0.0 +462 924.0 0.0 +463 926.0 0.0 +463 926.0 0.0 +466 1398.0 0.0 +466 1398.0 0.0 +466 1398.0 0.0 +467 467.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +47 47.0 0.0 +470 470.0 0.0 +472 472.0 0.0 +475 475.0 0.0 +477 477.0 0.0 +478 956.0 0.0 +478 956.0 0.0 +479 479.0 0.0 +480 1440.0 0.0 +480 1440.0 0.0 +480 1440.0 0.0 +481 481.0 0.0 +482 482.0 0.0 +483 483.0 0.0 +484 484.0 0.0 +485 485.0 0.0 +487 487.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +490 490.0 0.0 +491 491.0 0.0 +492 984.0 0.0 +492 984.0 0.0 +493 493.0 0.0 +494 494.0 0.0 +495 495.0 0.0 +496 496.0 0.0 +497 497.0 0.0 +498 1494.0 0.0 +498 1494.0 0.0 +498 1494.0 0.0 +5 15.0 0.0 +5 15.0 0.0 +5 15.0 0.0 +51 102.0 0.0 +51 102.0 0.0 +53 53.0 0.0 +54 54.0 0.0 +57 57.0 0.0 +58 116.0 0.0 +58 116.0 0.0 +64 64.0 0.0 +65 65.0 0.0 +66 66.0 0.0 +67 134.0 0.0 +67 134.0 0.0 +69 69.0 0.0 +70 210.0 0.0 +70 210.0 0.0 +70 210.0 0.0 +72 144.0 0.0 +72 144.0 0.0 +74 74.0 0.0 +76 152.0 0.0 +76 152.0 0.0 +77 77.0 0.0 +78 78.0 0.0 +8 8.0 0.0 +80 80.0 0.0 +82 82.0 0.0 +83 166.0 0.0 +83 166.0 0.0 +84 168.0 0.0 +84 168.0 0.0 +85 85.0 0.0 +86 86.0 0.0 +87 87.0 0.0 +9 9.0 0.0 +90 270.0 0.0 +90 270.0 0.0 +90 270.0 0.0 +92 92.0 0.0 +95 190.0 0.0 +95 190.0 0.0 +96 96.0 0.0 +97 194.0 0.0 +97 194.0 0.0 +98 196.0 0.0 +98 196.0 0.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +10 10.0 0.0 +100 200.0 0.0 +100 200.0 0.0 +103 206.0 0.0 +103 206.0 0.0 +104 208.0 0.0 +104 208.0 0.0 +105 105.0 0.0 +11 11.0 0.0 +111 111.0 0.0 +113 226.0 0.0 +113 226.0 0.0 +114 114.0 0.0 +116 116.0 0.0 +118 236.0 0.0 +118 236.0 0.0 +119 357.0 0.0 +119 357.0 0.0 +119 357.0 0.0 +12 24.0 0.0 +12 24.0 0.0 +120 240.0 0.0 +120 240.0 0.0 +125 250.0 0.0 +125 250.0 0.0 +126 126.0 0.0 +128 384.0 0.0 +128 384.0 0.0 +128 384.0 0.0 +129 258.0 0.0 +129 258.0 0.0 +131 131.0 0.0 +133 133.0 0.0 +134 268.0 0.0 +134 268.0 0.0 +136 136.0 0.0 +137 274.0 0.0 +137 274.0 0.0 +138 552.0 0.0 +138 552.0 0.0 +138 552.0 0.0 +138 552.0 0.0 +143 143.0 0.0 +145 145.0 0.0 +146 292.0 0.0 +146 292.0 0.0 +149 298.0 0.0 +149 298.0 0.0 +15 30.0 0.0 +15 30.0 0.0 +150 150.0 0.0 +152 304.0 0.0 +152 304.0 0.0 +153 153.0 0.0 +155 155.0 0.0 +156 156.0 0.0 +157 157.0 0.0 +158 158.0 0.0 +160 160.0 0.0 +162 162.0 0.0 +163 163.0 0.0 +164 328.0 0.0 +164 328.0 0.0 +165 330.0 0.0 +165 330.0 0.0 +166 166.0 0.0 +167 501.0 0.0 +167 501.0 0.0 +167 501.0 0.0 +168 168.0 0.0 +169 676.0 0.0 +169 676.0 0.0 +169 676.0 0.0 +169 676.0 0.0 +17 17.0 0.0 +170 170.0 0.0 +172 344.0 0.0 +172 344.0 0.0 +174 348.0 0.0 +174 348.0 0.0 +175 350.0 0.0 +175 350.0 0.0 +176 352.0 0.0 +176 352.0 0.0 +177 177.0 0.0 +178 178.0 0.0 +179 358.0 0.0 +179 358.0 0.0 +18 36.0 0.0 +18 36.0 0.0 +180 180.0 0.0 +181 181.0 0.0 +183 183.0 0.0 +186 186.0 0.0 +187 561.0 0.0 +187 561.0 0.0 +187 561.0 0.0 +189 189.0 0.0 +19 19.0 0.0 +190 190.0 0.0 +191 382.0 0.0 +191 382.0 0.0 +192 192.0 0.0 +193 579.0 0.0 +193 579.0 0.0 +193 579.0 0.0 +194 194.0 0.0 +195 390.0 0.0 +195 390.0 0.0 +196 196.0 0.0 +197 394.0 0.0 +197 394.0 0.0 +199 597.0 0.0 +199 597.0 0.0 +199 597.0 0.0 +2 2.0 0.0 +20 20.0 0.0 +200 400.0 0.0 +200 400.0 0.0 +201 201.0 0.0 +202 202.0 0.0 +203 406.0 0.0 +203 406.0 0.0 +205 410.0 0.0 +205 410.0 0.0 +207 414.0 0.0 +207 414.0 0.0 +208 624.0 0.0 +208 624.0 0.0 +208 624.0 0.0 +209 418.0 0.0 +209 418.0 0.0 +213 426.0 0.0 +213 426.0 0.0 +214 214.0 0.0 +216 432.0 0.0 +216 432.0 0.0 +217 434.0 0.0 +217 434.0 0.0 +218 218.0 0.0 +219 438.0 0.0 +219 438.0 0.0 +221 442.0 0.0 +221 442.0 0.0 +222 222.0 0.0 +223 446.0 0.0 +223 446.0 0.0 +224 448.0 0.0 +224 448.0 0.0 +226 226.0 0.0 +228 228.0 0.0 +229 458.0 0.0 +229 458.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +230 1150.0 0.0 +233 466.0 0.0 +233 466.0 0.0 +235 235.0 0.0 +237 474.0 0.0 +237 474.0 0.0 +238 476.0 0.0 +238 476.0 0.0 +239 478.0 0.0 +239 478.0 0.0 +24 48.0 0.0 +24 48.0 0.0 +241 241.0 0.0 +242 484.0 0.0 +242 484.0 0.0 +244 244.0 0.0 +247 247.0 0.0 +248 248.0 0.0 +249 249.0 0.0 +252 252.0 0.0 +255 510.0 0.0 +255 510.0 0.0 +256 512.0 0.0 +256 512.0 0.0 +257 257.0 0.0 +258 258.0 0.0 +26 52.0 0.0 +26 52.0 0.0 +260 260.0 0.0 +262 262.0 0.0 +263 263.0 0.0 +265 530.0 0.0 +265 530.0 0.0 +266 266.0 0.0 +27 27.0 0.0 +272 544.0 0.0 +272 544.0 0.0 +273 819.0 0.0 +273 819.0 0.0 +273 819.0 0.0 +274 274.0 0.0 +275 275.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +277 1108.0 0.0 +278 556.0 0.0 +278 556.0 0.0 +28 28.0 0.0 +280 560.0 0.0 +280 560.0 0.0 +281 562.0 0.0 +281 562.0 0.0 +282 564.0 0.0 +282 564.0 0.0 +283 283.0 0.0 +284 284.0 0.0 +285 285.0 0.0 +286 286.0 0.0 +287 287.0 0.0 +288 576.0 0.0 +288 576.0 0.0 +289 289.0 0.0 +291 291.0 0.0 +292 292.0 0.0 +296 296.0 0.0 +298 894.0 0.0 +298 894.0 0.0 +298 894.0 0.0 +30 30.0 0.0 +302 302.0 0.0 +305 305.0 0.0 +306 306.0 0.0 +307 614.0 0.0 +307 614.0 0.0 +308 308.0 0.0 +309 618.0 0.0 +309 618.0 0.0 +310 310.0 0.0 +311 933.0 0.0 +311 933.0 0.0 +311 933.0 0.0 +315 315.0 0.0 +316 948.0 0.0 +316 948.0 0.0 +316 948.0 0.0 +317 634.0 0.0 +317 634.0 0.0 +318 954.0 0.0 +318 954.0 0.0 +318 954.0 0.0 +321 642.0 0.0 +321 642.0 0.0 +322 644.0 0.0 +322 644.0 0.0 +323 323.0 0.0 +325 650.0 0.0 +325 650.0 0.0 +327 981.0 0.0 +327 981.0 0.0 +327 981.0 0.0 +33 33.0 0.0 +331 662.0 0.0 +331 662.0 0.0 +332 332.0 0.0 +333 666.0 0.0 +333 666.0 0.0 +335 335.0 0.0 +336 336.0 0.0 +338 338.0 0.0 +339 339.0 0.0 +34 34.0 0.0 +341 341.0 0.0 +342 684.0 0.0 +342 684.0 0.0 +344 688.0 0.0 +344 688.0 0.0 +345 345.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +348 1740.0 0.0 +35 105.0 0.0 +35 105.0 0.0 +35 105.0 0.0 +351 351.0 0.0 +353 706.0 0.0 +353 706.0 0.0 +356 356.0 0.0 +360 360.0 0.0 +362 362.0 0.0 +364 364.0 0.0 +365 365.0 0.0 +366 366.0 0.0 +367 734.0 0.0 +367 734.0 0.0 +368 368.0 0.0 +369 1107.0 0.0 +369 1107.0 0.0 +369 1107.0 0.0 +37 74.0 0.0 +37 74.0 0.0 +373 373.0 0.0 +374 374.0 0.0 +375 375.0 0.0 +377 377.0 0.0 +378 378.0 0.0 +379 379.0 0.0 +382 764.0 0.0 +382 764.0 0.0 +384 1152.0 0.0 +384 1152.0 0.0 +384 1152.0 0.0 +386 386.0 0.0 +389 389.0 0.0 +392 392.0 0.0 +393 393.0 0.0 +394 394.0 0.0 +395 790.0 0.0 +395 790.0 0.0 +396 1188.0 0.0 +396 1188.0 0.0 +396 1188.0 0.0 +397 794.0 0.0 +397 794.0 0.0 +399 798.0 0.0 +399 798.0 0.0 +4 4.0 0.0 +400 400.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +401 2005.0 0.0 +402 402.0 0.0 +403 1209.0 0.0 +403 1209.0 0.0 +403 1209.0 0.0 +404 808.0 0.0 +404 808.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +406 1624.0 0.0 +407 407.0 0.0 +409 1227.0 0.0 +409 1227.0 0.0 +409 1227.0 0.0 +41 41.0 0.0 +411 411.0 0.0 +413 826.0 0.0 +413 826.0 0.0 +414 828.0 0.0 +414 828.0 0.0 +417 1251.0 0.0 +417 1251.0 0.0 +417 1251.0 0.0 +418 418.0 0.0 +419 419.0 0.0 +42 84.0 0.0 +42 84.0 0.0 +421 421.0 0.0 +424 848.0 0.0 +424 848.0 0.0 +427 427.0 0.0 +429 858.0 0.0 +429 858.0 0.0 +43 43.0 0.0 +430 1290.0 0.0 +430 1290.0 0.0 +430 1290.0 0.0 +431 1293.0 0.0 +431 1293.0 0.0 +431 1293.0 0.0 +432 432.0 0.0 +435 435.0 0.0 +436 436.0 0.0 +437 437.0 0.0 +438 1314.0 0.0 +438 1314.0 0.0 +438 1314.0 0.0 +439 878.0 0.0 +439 878.0 0.0 +44 44.0 0.0 +443 443.0 0.0 +444 444.0 0.0 +446 446.0 0.0 +448 448.0 0.0 +449 449.0 0.0 +452 452.0 0.0 +453 453.0 0.0 +454 1362.0 0.0 +454 1362.0 0.0 +454 1362.0 0.0 +455 455.0 0.0 +457 457.0 0.0 +458 916.0 0.0 +458 916.0 0.0 +459 918.0 0.0 +459 918.0 0.0 +460 460.0 0.0 +462 924.0 0.0 +462 924.0 0.0 +463 926.0 0.0 +463 926.0 0.0 +466 1398.0 0.0 +466 1398.0 0.0 +466 1398.0 0.0 +467 467.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +468 1872.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +469 2345.0 0.0 +47 47.0 0.0 +470 470.0 0.0 +472 472.0 0.0 +475 475.0 0.0 +477 477.0 0.0 +478 956.0 0.0 +478 956.0 0.0 +479 479.0 0.0 +480 1440.0 0.0 +480 1440.0 0.0 +480 1440.0 0.0 +481 481.0 0.0 +482 482.0 0.0 +483 483.0 0.0 +484 484.0 0.0 +485 485.0 0.0 +487 487.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +489 1956.0 0.0 +490 490.0 0.0 +491 491.0 0.0 +492 984.0 0.0 +492 984.0 0.0 +493 493.0 0.0 +494 494.0 0.0 +495 495.0 0.0 +496 496.0 0.0 +497 497.0 0.0 +498 1494.0 0.0 +498 1494.0 0.0 +498 1494.0 0.0 +5 15.0 0.0 +5 15.0 0.0 +5 15.0 0.0 +51 102.0 0.0 +51 102.0 0.0 +53 53.0 0.0 +54 54.0 0.0 +57 57.0 0.0 +58 116.0 0.0 +58 116.0 0.0 +64 64.0 0.0 +65 65.0 0.0 +66 66.0 0.0 +67 134.0 0.0 +67 134.0 0.0 +69 69.0 0.0 +70 210.0 0.0 +70 210.0 0.0 +70 210.0 0.0 +72 144.0 0.0 +72 144.0 0.0 +74 74.0 0.0 +76 152.0 0.0 +76 152.0 0.0 +77 77.0 0.0 +78 78.0 0.0 +8 8.0 0.0 +80 80.0 0.0 +82 82.0 0.0 +83 166.0 0.0 +83 166.0 0.0 +84 168.0 0.0 +84 168.0 0.0 +85 85.0 0.0 +86 86.0 0.0 +87 87.0 0.0 +9 9.0 0.0 +90 270.0 0.0 +90 270.0 0.0 +90 270.0 0.0 +92 92.0 0.0 +95 190.0 0.0 +95 190.0 0.0 +96 96.0 0.0 +97 194.0 0.0 +97 194.0 0.0 +98 196.0 0.0 +98 196.0 0.0 +PREHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT (cast(key as int))+2 as key, sum(key) over(partition by key,value) as c1, sum(value) over(partition by key) as c2 from src)r1 where (cast(key as int) + 1) > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +2 0.0 0.0 +2 0.0 0.0 +2 0.0 0.0 +12 10.0 0.0 +102 200.0 0.0 +102 200.0 0.0 +105 206.0 0.0 +105 206.0 0.0 +106 208.0 0.0 +106 208.0 0.0 +107 105.0 0.0 +13 11.0 0.0 +113 111.0 0.0 +115 226.0 0.0 +115 226.0 0.0 +116 114.0 0.0 +118 116.0 0.0 +120 236.0 0.0 +120 236.0 0.0 +121 357.0 0.0 +121 357.0 0.0 +121 357.0 0.0 +14 24.0 0.0 +14 24.0 0.0 +122 240.0 0.0 +122 240.0 0.0 +127 250.0 0.0 +127 250.0 0.0 +128 126.0 0.0 +130 384.0 0.0 +130 384.0 0.0 +130 384.0 0.0 +131 258.0 0.0 +131 258.0 0.0 +133 131.0 0.0 +135 133.0 0.0 +136 268.0 0.0 +136 268.0 0.0 +138 136.0 0.0 +139 274.0 0.0 +139 274.0 0.0 +140 552.0 0.0 +140 552.0 0.0 +140 552.0 0.0 +140 552.0 0.0 +145 143.0 0.0 +147 145.0 0.0 +148 292.0 0.0 +148 292.0 0.0 +151 298.0 0.0 +151 298.0 0.0 +17 30.0 0.0 +17 30.0 0.0 +152 150.0 0.0 +154 304.0 0.0 +154 304.0 0.0 +155 153.0 0.0 +157 155.0 0.0 +158 156.0 0.0 +159 157.0 0.0 +160 158.0 0.0 +162 160.0 0.0 +164 162.0 0.0 +165 163.0 0.0 +166 328.0 0.0 +166 328.0 0.0 +167 330.0 0.0 +167 330.0 0.0 +168 166.0 0.0 +169 501.0 0.0 +169 501.0 0.0 +169 501.0 0.0 +170 168.0 0.0 +171 676.0 0.0 +171 676.0 0.0 +171 676.0 0.0 +171 676.0 0.0 +19 17.0 0.0 +172 170.0 0.0 +174 344.0 0.0 +174 344.0 0.0 +176 348.0 0.0 +176 348.0 0.0 +177 350.0 0.0 +177 350.0 0.0 +178 352.0 0.0 +178 352.0 0.0 +179 177.0 0.0 +180 178.0 0.0 +181 358.0 0.0 +181 358.0 0.0 +20 36.0 0.0 +20 36.0 0.0 +182 180.0 0.0 +183 181.0 0.0 +185 183.0 0.0 +188 186.0 0.0 +189 561.0 0.0 +189 561.0 0.0 +189 561.0 0.0 +191 189.0 0.0 +21 19.0 0.0 +192 190.0 0.0 +193 382.0 0.0 +193 382.0 0.0 +194 192.0 0.0 +195 579.0 0.0 +195 579.0 0.0 +195 579.0 0.0 +196 194.0 0.0 +197 390.0 0.0 +197 390.0 0.0 +198 196.0 0.0 +199 394.0 0.0 +199 394.0 0.0 +201 597.0 0.0 +201 597.0 0.0 +201 597.0 0.0 +4 2.0 0.0 +22 20.0 0.0 +202 400.0 0.0 +202 400.0 0.0 +203 201.0 0.0 +204 202.0 0.0 +205 406.0 0.0 +205 406.0 0.0 +207 410.0 0.0 +207 410.0 0.0 +209 414.0 0.0 +209 414.0 0.0 +210 624.0 0.0 +210 624.0 0.0 +210 624.0 0.0 +211 418.0 0.0 +211 418.0 0.0 +215 426.0 0.0 +215 426.0 0.0 +216 214.0 0.0 +218 432.0 0.0 +218 432.0 0.0 +219 434.0 0.0 +219 434.0 0.0 +220 218.0 0.0 +221 438.0 0.0 +221 438.0 0.0 +223 442.0 0.0 +223 442.0 0.0 +224 222.0 0.0 +225 446.0 0.0 +225 446.0 0.0 +226 448.0 0.0 +226 448.0 0.0 +228 226.0 0.0 +230 228.0 0.0 +231 458.0 0.0 +231 458.0 0.0 +232 1150.0 0.0 +232 1150.0 0.0 +232 1150.0 0.0 +232 1150.0 0.0 +232 1150.0 0.0 +235 466.0 0.0 +235 466.0 0.0 +237 235.0 0.0 +239 474.0 0.0 +239 474.0 0.0 +240 476.0 0.0 +240 476.0 0.0 +241 478.0 0.0 +241 478.0 0.0 +26 48.0 0.0 +26 48.0 0.0 +243 241.0 0.0 +244 484.0 0.0 +244 484.0 0.0 +246 244.0 0.0 +249 247.0 0.0 +250 248.0 0.0 +251 249.0 0.0 +254 252.0 0.0 +257 510.0 0.0 +257 510.0 0.0 +258 512.0 0.0 +258 512.0 0.0 +259 257.0 0.0 +260 258.0 0.0 +28 52.0 0.0 +28 52.0 0.0 +262 260.0 0.0 +264 262.0 0.0 +265 263.0 0.0 +267 530.0 0.0 +267 530.0 0.0 +268 266.0 0.0 +29 27.0 0.0 +274 544.0 0.0 +274 544.0 0.0 +275 819.0 0.0 +275 819.0 0.0 +275 819.0 0.0 +276 274.0 0.0 +277 275.0 0.0 +279 1108.0 0.0 +279 1108.0 0.0 +279 1108.0 0.0 +279 1108.0 0.0 +280 556.0 0.0 +280 556.0 0.0 +30 28.0 0.0 +282 560.0 0.0 +282 560.0 0.0 +283 562.0 0.0 +283 562.0 0.0 +284 564.0 0.0 +284 564.0 0.0 +285 283.0 0.0 +286 284.0 0.0 +287 285.0 0.0 +288 286.0 0.0 +289 287.0 0.0 +290 576.0 0.0 +290 576.0 0.0 +291 289.0 0.0 +293 291.0 0.0 +294 292.0 0.0 +298 296.0 0.0 +300 894.0 0.0 +300 894.0 0.0 +300 894.0 0.0 +32 30.0 0.0 +304 302.0 0.0 +307 305.0 0.0 +308 306.0 0.0 +309 614.0 0.0 +309 614.0 0.0 +310 308.0 0.0 +311 618.0 0.0 +311 618.0 0.0 +312 310.0 0.0 +313 933.0 0.0 +313 933.0 0.0 +313 933.0 0.0 +317 315.0 0.0 +318 948.0 0.0 +318 948.0 0.0 +318 948.0 0.0 +319 634.0 0.0 +319 634.0 0.0 +320 954.0 0.0 +320 954.0 0.0 +320 954.0 0.0 +323 642.0 0.0 +323 642.0 0.0 +324 644.0 0.0 +324 644.0 0.0 +325 323.0 0.0 +327 650.0 0.0 +327 650.0 0.0 +329 981.0 0.0 +329 981.0 0.0 +329 981.0 0.0 +35 33.0 0.0 +333 662.0 0.0 +333 662.0 0.0 +334 332.0 0.0 +335 666.0 0.0 +335 666.0 0.0 +337 335.0 0.0 +338 336.0 0.0 +340 338.0 0.0 +341 339.0 0.0 +36 34.0 0.0 +343 341.0 0.0 +344 684.0 0.0 +344 684.0 0.0 +346 688.0 0.0 +346 688.0 0.0 +347 345.0 0.0 +350 1740.0 0.0 +350 1740.0 0.0 +350 1740.0 0.0 +350 1740.0 0.0 +350 1740.0 0.0 +37 105.0 0.0 +37 105.0 0.0 +37 105.0 0.0 +353 351.0 0.0 +355 706.0 0.0 +355 706.0 0.0 +358 356.0 0.0 +362 360.0 0.0 +364 362.0 0.0 +366 364.0 0.0 +367 365.0 0.0 +368 366.0 0.0 +369 734.0 0.0 +369 734.0 0.0 +370 368.0 0.0 +371 1107.0 0.0 +371 1107.0 0.0 +371 1107.0 0.0 +39 74.0 0.0 +39 74.0 0.0 +375 373.0 0.0 +376 374.0 0.0 +377 375.0 0.0 +379 377.0 0.0 +380 378.0 0.0 +381 379.0 0.0 +384 764.0 0.0 +384 764.0 0.0 +386 1152.0 0.0 +386 1152.0 0.0 +386 1152.0 0.0 +388 386.0 0.0 +391 389.0 0.0 +394 392.0 0.0 +395 393.0 0.0 +396 394.0 0.0 +397 790.0 0.0 +397 790.0 0.0 +398 1188.0 0.0 +398 1188.0 0.0 +398 1188.0 0.0 +399 794.0 0.0 +399 794.0 0.0 +401 798.0 0.0 +401 798.0 0.0 +6 4.0 0.0 +402 400.0 0.0 +403 2005.0 0.0 +403 2005.0 0.0 +403 2005.0 0.0 +403 2005.0 0.0 +403 2005.0 0.0 +404 402.0 0.0 +405 1209.0 0.0 +405 1209.0 0.0 +405 1209.0 0.0 +406 808.0 0.0 +406 808.0 0.0 +408 1624.0 0.0 +408 1624.0 0.0 +408 1624.0 0.0 +408 1624.0 0.0 +409 407.0 0.0 +411 1227.0 0.0 +411 1227.0 0.0 +411 1227.0 0.0 +43 41.0 0.0 +413 411.0 0.0 +415 826.0 0.0 +415 826.0 0.0 +416 828.0 0.0 +416 828.0 0.0 +419 1251.0 0.0 +419 1251.0 0.0 +419 1251.0 0.0 +420 418.0 0.0 +421 419.0 0.0 +44 84.0 0.0 +44 84.0 0.0 +423 421.0 0.0 +426 848.0 0.0 +426 848.0 0.0 +429 427.0 0.0 +431 858.0 0.0 +431 858.0 0.0 +45 43.0 0.0 +432 1290.0 0.0 +432 1290.0 0.0 +432 1290.0 0.0 +433 1293.0 0.0 +433 1293.0 0.0 +433 1293.0 0.0 +434 432.0 0.0 +437 435.0 0.0 +438 436.0 0.0 +439 437.0 0.0 +440 1314.0 0.0 +440 1314.0 0.0 +440 1314.0 0.0 +441 878.0 0.0 +441 878.0 0.0 +46 44.0 0.0 +445 443.0 0.0 +446 444.0 0.0 +448 446.0 0.0 +450 448.0 0.0 +451 449.0 0.0 +454 452.0 0.0 +455 453.0 0.0 +456 1362.0 0.0 +456 1362.0 0.0 +456 1362.0 0.0 +457 455.0 0.0 +459 457.0 0.0 +460 916.0 0.0 +460 916.0 0.0 +461 918.0 0.0 +461 918.0 0.0 +462 460.0 0.0 +464 924.0 0.0 +464 924.0 0.0 +465 926.0 0.0 +465 926.0 0.0 +468 1398.0 0.0 +468 1398.0 0.0 +468 1398.0 0.0 +469 467.0 0.0 +470 1872.0 0.0 +470 1872.0 0.0 +470 1872.0 0.0 +470 1872.0 0.0 +471 2345.0 0.0 +471 2345.0 0.0 +471 2345.0 0.0 +471 2345.0 0.0 +471 2345.0 0.0 +49 47.0 0.0 +472 470.0 0.0 +474 472.0 0.0 +477 475.0 0.0 +479 477.0 0.0 +480 956.0 0.0 +480 956.0 0.0 +481 479.0 0.0 +482 1440.0 0.0 +482 1440.0 0.0 +482 1440.0 0.0 +483 481.0 0.0 +484 482.0 0.0 +485 483.0 0.0 +486 484.0 0.0 +487 485.0 0.0 +489 487.0 0.0 +491 1956.0 0.0 +491 1956.0 0.0 +491 1956.0 0.0 +491 1956.0 0.0 +492 490.0 0.0 +493 491.0 0.0 +494 984.0 0.0 +494 984.0 0.0 +495 493.0 0.0 +496 494.0 0.0 +497 495.0 0.0 +498 496.0 0.0 +499 497.0 0.0 +500 1494.0 0.0 +500 1494.0 0.0 +500 1494.0 0.0 +7 15.0 0.0 +7 15.0 0.0 +7 15.0 0.0 +53 102.0 0.0 +53 102.0 0.0 +55 53.0 0.0 +56 54.0 0.0 +59 57.0 0.0 +60 116.0 0.0 +60 116.0 0.0 +66 64.0 0.0 +67 65.0 0.0 +68 66.0 0.0 +69 134.0 0.0 +69 134.0 0.0 +71 69.0 0.0 +72 210.0 0.0 +72 210.0 0.0 +72 210.0 0.0 +74 144.0 0.0 +74 144.0 0.0 +76 74.0 0.0 +78 152.0 0.0 +78 152.0 0.0 +79 77.0 0.0 +80 78.0 0.0 +10 8.0 0.0 +82 80.0 0.0 +84 82.0 0.0 +85 166.0 0.0 +85 166.0 0.0 +86 168.0 0.0 +86 168.0 0.0 +87 85.0 0.0 +88 86.0 0.0 +89 87.0 0.0 +11 9.0 0.0 +92 270.0 0.0 +92 270.0 0.0 +92 270.0 0.0 +94 92.0 0.0 +97 190.0 0.0 +97 190.0 0.0 +98 96.0 0.0 +99 194.0 0.0 +99 194.0 0.0 +100 196.0 0.0 +100 196.0 0.0 +PREHOOK: query: -- Test predicate is not getting pushed down when multiple windows are involved and they don't have common partition keys +select * from (SELECT key, sum(key) over(partition by key,value) as c1, avg(value) over(partition by value) as c2 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- Test predicate is not getting pushed down when multiple windows are involved and they don't have common partition keys +select * from (SELECT key, sum(key) over(partition by key,value) as c1, avg(value) over(partition by value) as c2 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +20 20.0 NULL +200 400.0 NULL +200 400.0 NULL +201 201.0 NULL +202 202.0 NULL +203 406.0 NULL +203 406.0 NULL +205 410.0 NULL +205 410.0 NULL +207 414.0 NULL +207 414.0 NULL +208 624.0 NULL +208 624.0 NULL +208 624.0 NULL +209 418.0 NULL +209 418.0 NULL +213 426.0 NULL +213 426.0 NULL +214 214.0 NULL +216 432.0 NULL +216 432.0 NULL +217 434.0 NULL +217 434.0 NULL +218 218.0 NULL +219 438.0 NULL +219 438.0 NULL +221 442.0 NULL +221 442.0 NULL +222 222.0 NULL +223 446.0 NULL +223 446.0 NULL +224 448.0 NULL +224 448.0 NULL +226 226.0 NULL +228 228.0 NULL +229 458.0 NULL +229 458.0 NULL +230 1150.0 NULL +230 1150.0 NULL +230 1150.0 NULL +230 1150.0 NULL +230 1150.0 NULL +233 466.0 NULL +233 466.0 NULL +235 235.0 NULL +237 474.0 NULL +237 474.0 NULL +238 476.0 NULL +238 476.0 NULL +239 478.0 NULL +239 478.0 NULL +24 48.0 NULL +24 48.0 NULL +241 241.0 NULL +242 484.0 NULL +242 484.0 NULL +244 244.0 NULL +247 247.0 NULL +248 248.0 NULL +249 249.0 NULL +252 252.0 NULL +255 510.0 NULL +255 510.0 NULL +256 512.0 NULL +256 512.0 NULL +257 257.0 NULL +258 258.0 NULL +26 52.0 NULL +26 52.0 NULL +260 260.0 NULL +262 262.0 NULL +263 263.0 NULL +265 530.0 NULL +265 530.0 NULL +266 266.0 NULL +27 27.0 NULL +272 544.0 NULL +272 544.0 NULL +273 819.0 NULL +273 819.0 NULL +273 819.0 NULL +274 274.0 NULL +275 275.0 NULL +277 1108.0 NULL +277 1108.0 NULL +277 1108.0 NULL +277 1108.0 NULL +278 556.0 NULL +278 556.0 NULL +28 28.0 NULL +280 560.0 NULL +280 560.0 NULL +281 562.0 NULL +281 562.0 NULL +282 564.0 NULL +282 564.0 NULL +283 283.0 NULL +284 284.0 NULL +285 285.0 NULL +286 286.0 NULL +287 287.0 NULL +288 576.0 NULL +288 576.0 NULL +289 289.0 NULL +291 291.0 NULL +292 292.0 NULL +296 296.0 NULL +298 894.0 NULL +298 894.0 NULL +298 894.0 NULL +30 30.0 NULL +302 302.0 NULL +305 305.0 NULL +306 306.0 NULL +307 614.0 NULL +307 614.0 NULL +308 308.0 NULL +309 618.0 NULL +309 618.0 NULL +310 310.0 NULL +311 933.0 NULL +311 933.0 NULL +311 933.0 NULL +315 315.0 NULL +316 948.0 NULL +316 948.0 NULL +316 948.0 NULL +317 634.0 NULL +317 634.0 NULL +318 954.0 NULL +318 954.0 NULL +318 954.0 NULL +321 642.0 NULL +321 642.0 NULL +322 644.0 NULL +322 644.0 NULL +323 323.0 NULL +325 650.0 NULL +325 650.0 NULL +327 981.0 NULL +327 981.0 NULL +327 981.0 NULL +33 33.0 NULL +331 662.0 NULL +331 662.0 NULL +332 332.0 NULL +333 666.0 NULL +333 666.0 NULL +335 335.0 NULL +336 336.0 NULL +338 338.0 NULL +339 339.0 NULL +34 34.0 NULL +341 341.0 NULL +342 684.0 NULL +342 684.0 NULL +344 688.0 NULL +344 688.0 NULL +345 345.0 NULL +348 1740.0 NULL +348 1740.0 NULL +348 1740.0 NULL +348 1740.0 NULL +348 1740.0 NULL +35 105.0 NULL +35 105.0 NULL +35 105.0 NULL +351 351.0 NULL +353 706.0 NULL +353 706.0 NULL +356 356.0 NULL +360 360.0 NULL +362 362.0 NULL +364 364.0 NULL +365 365.0 NULL +366 366.0 NULL +367 734.0 NULL +367 734.0 NULL +368 368.0 NULL +369 1107.0 NULL +369 1107.0 NULL +369 1107.0 NULL +37 74.0 NULL +37 74.0 NULL +373 373.0 NULL +374 374.0 NULL +375 375.0 NULL +377 377.0 NULL +378 378.0 NULL +379 379.0 NULL +382 764.0 NULL +382 764.0 NULL +384 1152.0 NULL +384 1152.0 NULL +384 1152.0 NULL +386 386.0 NULL +389 389.0 NULL +392 392.0 NULL +393 393.0 NULL +394 394.0 NULL +395 790.0 NULL +395 790.0 NULL +396 1188.0 NULL +396 1188.0 NULL +396 1188.0 NULL +397 794.0 NULL +397 794.0 NULL +399 798.0 NULL +399 798.0 NULL +4 4.0 NULL +400 400.0 NULL +401 2005.0 NULL +401 2005.0 NULL +401 2005.0 NULL +401 2005.0 NULL +401 2005.0 NULL +402 402.0 NULL +403 1209.0 NULL +403 1209.0 NULL +403 1209.0 NULL +404 808.0 NULL +404 808.0 NULL +406 1624.0 NULL +406 1624.0 NULL +406 1624.0 NULL +406 1624.0 NULL +407 407.0 NULL +409 1227.0 NULL +409 1227.0 NULL +409 1227.0 NULL +41 41.0 NULL +411 411.0 NULL +413 826.0 NULL +413 826.0 NULL +414 828.0 NULL +414 828.0 NULL +417 1251.0 NULL +417 1251.0 NULL +417 1251.0 NULL +418 418.0 NULL +419 419.0 NULL +42 84.0 NULL +42 84.0 NULL +421 421.0 NULL +424 848.0 NULL +424 848.0 NULL +427 427.0 NULL +429 858.0 NULL +429 858.0 NULL +43 43.0 NULL +430 1290.0 NULL +430 1290.0 NULL +430 1290.0 NULL +431 1293.0 NULL +431 1293.0 NULL +431 1293.0 NULL +432 432.0 NULL +435 435.0 NULL +436 436.0 NULL +437 437.0 NULL +438 1314.0 NULL +438 1314.0 NULL +438 1314.0 NULL +439 878.0 NULL +439 878.0 NULL +44 44.0 NULL +443 443.0 NULL +444 444.0 NULL +446 446.0 NULL +448 448.0 NULL +449 449.0 NULL +452 452.0 NULL +453 453.0 NULL +454 1362.0 NULL +454 1362.0 NULL +454 1362.0 NULL +455 455.0 NULL +457 457.0 NULL +458 916.0 NULL +458 916.0 NULL +459 918.0 NULL +459 918.0 NULL +460 460.0 NULL +462 924.0 NULL +462 924.0 NULL +463 926.0 NULL +463 926.0 NULL +466 1398.0 NULL +466 1398.0 NULL +466 1398.0 NULL +467 467.0 NULL +468 1872.0 NULL +468 1872.0 NULL +468 1872.0 NULL +468 1872.0 NULL +469 2345.0 NULL +469 2345.0 NULL +469 2345.0 NULL +469 2345.0 NULL +469 2345.0 NULL +47 47.0 NULL +470 470.0 NULL +472 472.0 NULL +475 475.0 NULL +477 477.0 NULL +478 956.0 NULL +478 956.0 NULL +479 479.0 NULL +480 1440.0 NULL +480 1440.0 NULL +480 1440.0 NULL +481 481.0 NULL +482 482.0 NULL +483 483.0 NULL +484 484.0 NULL +485 485.0 NULL +487 487.0 NULL +489 1956.0 NULL +489 1956.0 NULL +489 1956.0 NULL +489 1956.0 NULL +490 490.0 NULL +491 491.0 NULL +492 984.0 NULL +492 984.0 NULL +493 493.0 NULL +494 494.0 NULL +495 495.0 NULL +496 496.0 NULL +497 497.0 NULL +498 1494.0 NULL +498 1494.0 NULL +498 1494.0 NULL +5 15.0 NULL +5 15.0 NULL +5 15.0 NULL +51 102.0 NULL +51 102.0 NULL +53 53.0 NULL +54 54.0 NULL +57 57.0 NULL +58 116.0 NULL +58 116.0 NULL +64 64.0 NULL +65 65.0 NULL +66 66.0 NULL +67 134.0 NULL +67 134.0 NULL +69 69.0 NULL +70 210.0 NULL +70 210.0 NULL +70 210.0 NULL +72 144.0 NULL +72 144.0 NULL +74 74.0 NULL +76 152.0 NULL +76 152.0 NULL +77 77.0 NULL +78 78.0 NULL +8 8.0 NULL +80 80.0 NULL +82 82.0 NULL +83 166.0 NULL +83 166.0 NULL +84 168.0 NULL +84 168.0 NULL +85 85.0 NULL +86 86.0 NULL +87 87.0 NULL +9 9.0 NULL +90 270.0 NULL +90 270.0 NULL +90 270.0 NULL +92 92.0 NULL +95 190.0 NULL +95 190.0 NULL +96 96.0 NULL +97 194.0 NULL +97 194.0 NULL +98 196.0 NULL +98 196.0 NULL +PREHOOK: query: -- Test predicate is not getting pushed down when window has compound partition key +select * from (SELECT key, sum(key) over(partition by key + 2) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- Test predicate is not getting pushed down when window has compound partition key +select * from (SELECT key, sum(key) over(partition by key + 2) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +4 4.0 +5 15.0 +5 15.0 +5 15.0 +8 8.0 +9 9.0 +20 20.0 +24 48.0 +24 48.0 +26 52.0 +26 52.0 +27 27.0 +28 28.0 +30 30.0 +33 33.0 +34 34.0 +35 105.0 +35 105.0 +35 105.0 +37 74.0 +37 74.0 +41 41.0 +42 84.0 +42 84.0 +43 43.0 +44 44.0 +47 47.0 +51 102.0 +51 102.0 +53 53.0 +54 54.0 +57 57.0 +58 116.0 +58 116.0 +64 64.0 +65 65.0 +66 66.0 +67 134.0 +67 134.0 +69 69.0 +70 210.0 +70 210.0 +70 210.0 +72 144.0 +72 144.0 +74 74.0 +76 152.0 +76 152.0 +77 77.0 +78 78.0 +80 80.0 +82 82.0 +83 166.0 +83 166.0 +84 168.0 +84 168.0 +85 85.0 +86 86.0 +87 87.0 +90 270.0 +90 270.0 +90 270.0 +92 92.0 +95 190.0 +95 190.0 +96 96.0 +97 194.0 +97 194.0 +98 196.0 +98 196.0 +200 400.0 +200 400.0 +201 201.0 +202 202.0 +203 406.0 +203 406.0 +205 410.0 +205 410.0 +207 414.0 +207 414.0 +208 624.0 +208 624.0 +208 624.0 +209 418.0 +209 418.0 +213 426.0 +213 426.0 +214 214.0 +216 432.0 +216 432.0 +217 434.0 +217 434.0 +218 218.0 +219 438.0 +219 438.0 +221 442.0 +221 442.0 +222 222.0 +223 446.0 +223 446.0 +224 448.0 +224 448.0 +226 226.0 +228 228.0 +229 458.0 +229 458.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +230 1150.0 +233 466.0 +233 466.0 +235 235.0 +237 474.0 +237 474.0 +238 476.0 +238 476.0 +239 478.0 +239 478.0 +241 241.0 +242 484.0 +242 484.0 +244 244.0 +247 247.0 +248 248.0 +249 249.0 +252 252.0 +255 510.0 +255 510.0 +256 512.0 +256 512.0 +257 257.0 +258 258.0 +260 260.0 +262 262.0 +263 263.0 +265 530.0 +265 530.0 +266 266.0 +272 544.0 +272 544.0 +273 819.0 +273 819.0 +273 819.0 +274 274.0 +275 275.0 +277 1108.0 +277 1108.0 +277 1108.0 +277 1108.0 +278 556.0 +278 556.0 +280 560.0 +280 560.0 +281 562.0 +281 562.0 +282 564.0 +282 564.0 +283 283.0 +284 284.0 +285 285.0 +286 286.0 +287 287.0 +288 576.0 +288 576.0 +289 289.0 +291 291.0 +292 292.0 +296 296.0 +298 894.0 +298 894.0 +298 894.0 +302 302.0 +305 305.0 +306 306.0 +307 614.0 +307 614.0 +308 308.0 +309 618.0 +309 618.0 +310 310.0 +311 933.0 +311 933.0 +311 933.0 +315 315.0 +316 948.0 +316 948.0 +316 948.0 +317 634.0 +317 634.0 +318 954.0 +318 954.0 +318 954.0 +321 642.0 +321 642.0 +322 644.0 +322 644.0 +323 323.0 +325 650.0 +325 650.0 +327 981.0 +327 981.0 +327 981.0 +331 662.0 +331 662.0 +332 332.0 +333 666.0 +333 666.0 +335 335.0 +336 336.0 +338 338.0 +339 339.0 +341 341.0 +342 684.0 +342 684.0 +344 688.0 +344 688.0 +345 345.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +348 1740.0 +351 351.0 +353 706.0 +353 706.0 +356 356.0 +360 360.0 +362 362.0 +364 364.0 +365 365.0 +366 366.0 +367 734.0 +367 734.0 +368 368.0 +369 1107.0 +369 1107.0 +369 1107.0 +373 373.0 +374 374.0 +375 375.0 +377 377.0 +378 378.0 +379 379.0 +382 764.0 +382 764.0 +384 1152.0 +384 1152.0 +384 1152.0 +386 386.0 +389 389.0 +392 392.0 +393 393.0 +394 394.0 +395 790.0 +395 790.0 +396 1188.0 +396 1188.0 +396 1188.0 +397 794.0 +397 794.0 +399 798.0 +399 798.0 +400 400.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +401 2005.0 +402 402.0 +403 1209.0 +403 1209.0 +403 1209.0 +404 808.0 +404 808.0 +406 1624.0 +406 1624.0 +406 1624.0 +406 1624.0 +407 407.0 +409 1227.0 +409 1227.0 +409 1227.0 +411 411.0 +413 826.0 +413 826.0 +414 828.0 +414 828.0 +417 1251.0 +417 1251.0 +417 1251.0 +418 418.0 +419 419.0 +421 421.0 +424 848.0 +424 848.0 +427 427.0 +429 858.0 +429 858.0 +430 1290.0 +430 1290.0 +430 1290.0 +431 1293.0 +431 1293.0 +431 1293.0 +432 432.0 +435 435.0 +436 436.0 +437 437.0 +438 1314.0 +438 1314.0 +438 1314.0 +439 878.0 +439 878.0 +443 443.0 +444 444.0 +446 446.0 +448 448.0 +449 449.0 +452 452.0 +453 453.0 +454 1362.0 +454 1362.0 +454 1362.0 +455 455.0 +457 457.0 +458 916.0 +458 916.0 +459 918.0 +459 918.0 +460 460.0 +462 924.0 +462 924.0 +463 926.0 +463 926.0 +466 1398.0 +466 1398.0 +466 1398.0 +467 467.0 +468 1872.0 +468 1872.0 +468 1872.0 +468 1872.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +469 2345.0 +470 470.0 +472 472.0 +475 475.0 +477 477.0 +478 956.0 +478 956.0 +479 479.0 +480 1440.0 +480 1440.0 +480 1440.0 +481 481.0 +482 482.0 +483 483.0 +484 484.0 +485 485.0 +487 487.0 +489 1956.0 +489 1956.0 +489 1956.0 +489 1956.0 +490 490.0 +491 491.0 +492 984.0 +492 984.0 +493 493.0 +494 494.0 +495 495.0 +496 496.0 +497 497.0 +498 1494.0 +498 1494.0 +498 1494.0 +PREHOOK: query: select * from (SELECT key, sum(key) over(partition by key + value) as c1 from src)r1 where key > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, sum(key) over(partition by key + value) as c1 from src)r1 where key > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +97 130091.0 +200 130091.0 +400 130091.0 +403 130091.0 +90 130091.0 +222 130091.0 +477 130091.0 +414 130091.0 +307 130091.0 +348 130091.0 +448 130091.0 +37 130091.0 +28 130091.0 +84 130091.0 +315 130091.0 +469 130091.0 +97 130091.0 +344 130091.0 +281 130091.0 +273 130091.0 +348 130091.0 +285 130091.0 +362 130091.0 +458 130091.0 +498 130091.0 +341 130091.0 +9 130091.0 +298 130091.0 +492 130091.0 +462 130091.0 +379 130091.0 +384 130091.0 +67 130091.0 +26 130091.0 +256 130091.0 +384 130091.0 +407 130091.0 +421 130091.0 +401 130091.0 +375 130091.0 +454 130091.0 +406 130091.0 +233 130091.0 +462 130091.0 +214 130091.0 +353 130091.0 +83 130091.0 +480 130091.0 +265 130091.0 +249 130091.0 +207 130091.0 +460 130091.0 +493 130091.0 +333 130091.0 +317 130091.0 +310 130091.0 +468 130091.0 +478 130091.0 +230 130091.0 +277 130091.0 +325 130091.0 +323 130091.0 +443 130091.0 +429 130091.0 +444 130091.0 +417 130091.0 +305 130091.0 +479 130091.0 +248 130091.0 +360 130091.0 +439 130091.0 +237 130091.0 +491 130091.0 +200 130091.0 +414 130091.0 +438 130091.0 +70 130091.0 +255 130091.0 +351 130091.0 +24 130091.0 +291 130091.0 +480 130091.0 +397 130091.0 +70 130091.0 +5 130091.0 +382 130091.0 +424 130091.0 +431 130091.0 +298 130091.0 +478 130091.0 +454 130091.0 +431 130091.0 +217 130091.0 +201 130091.0 +396 130091.0 +424 130091.0 +348 130091.0 +262 130091.0 +203 130091.0 +90 130091.0 +258 130091.0 +401 130091.0 +406 130091.0 +409 130091.0 +406 130091.0 +257 130091.0 +53 130091.0 +483 130091.0 +403 130091.0 +366 130091.0 +466 130091.0 +335 130091.0 +321 130091.0 +44 130091.0 +80 130091.0 +235 130091.0 +331 130091.0 +283 130091.0 +35 130091.0 +280 130091.0 +463 130091.0 +469 130091.0 +229 130091.0 +316 130091.0 +202 130091.0 +432 130091.0 +467 130091.0 +438 130091.0 +244 130091.0 +5 130091.0 +288 130091.0 +401 130091.0 +480 130091.0 +487 130091.0 +70 130091.0 +263 130091.0 +256 130091.0 +223 130091.0 +485 130091.0 +239 130091.0 +219 130091.0 +274 130091.0 +344 130091.0 +367 130091.0 +216 130091.0 +296 130091.0 +368 130091.0 +33 130091.0 +230 130091.0 +69 130091.0 +342 130091.0 +74 130091.0 +76 130091.0 +468 130091.0 +64 130091.0 +209 130091.0 +30 130091.0 +453 130091.0 +228 130091.0 +218 130091.0 +449 130091.0 +492 130091.0 +223 130091.0 +41 130091.0 +76 130091.0 +78 130091.0 +458 130091.0 +489 130091.0 +430 130091.0 +321 130091.0 +42 130091.0 +498 130091.0 +322 130091.0 +472 130091.0 +233 130091.0 +229 130091.0 +34 130091.0 +95 130091.0 +336 130091.0 +35 130091.0 +58 130091.0 +395 130091.0 +317 130091.0 +396 130091.0 +402 130091.0 +497 130091.0 +5 130091.0 +226 130091.0 +452 130091.0 +242 130091.0 +401 130091.0 +331 130091.0 +272 130091.0 +392 130091.0 +369 130091.0 +242 130091.0 +327 130091.0 +389 130091.0 +309 130091.0 +224 130091.0 +306 130091.0 +273 130091.0 +277 130091.0 +435 130091.0 +307 130091.0 +90 130091.0 +72 130091.0 +419 130091.0 +238 130091.0 +282 130091.0 +395 130091.0 +364 130091.0 +87 130091.0 +490 130091.0 +77 130091.0 +85 130091.0 +413 130091.0 +316 130091.0 +369 130091.0 +470 130091.0 +409 130091.0 +318 130091.0 +318 130091.0 +282 130091.0 +98 130091.0 +457 130091.0 +481 130091.0 +288 130091.0 +95 130091.0 +308 130091.0 +468 130091.0 +469 130091.0 +436 130091.0 +43 130091.0 +404 130091.0 +51 130091.0 +205 130091.0 +230 130091.0 +327 130091.0 +26 130091.0 +96 130091.0 +418 130091.0 +298 130091.0 +454 130091.0 +393 130091.0 +468 130091.0 +322 130091.0 +496 130091.0 +42 130091.0 +431 130091.0 +463 130091.0 +24 130091.0 +348 130091.0 +208 130091.0 +230 130091.0 +411 130091.0 +8 130091.0 +58 130091.0 +466 130091.0 +348 130091.0 +84 130091.0 +217 130091.0 +272 130091.0 +373 130091.0 +353 130091.0 +489 130091.0 +384 130091.0 +404 130091.0 +260 130091.0 +67 130091.0 +230 130091.0 +284 130091.0 +333 130091.0 +83 130091.0 +241 130091.0 +275 130091.0 +311 130091.0 +332 130091.0 +318 130091.0 +65 130091.0 +221 130091.0 +289 130091.0 +278 130091.0 +430 130091.0 +216 130091.0 +213 130091.0 +239 130091.0 +51 130091.0 +459 130091.0 +54 130091.0 +286 130091.0 +469 130091.0 +437 130091.0 +386 130091.0 +498 130091.0 +382 130091.0 +399 130091.0 +356 130091.0 +208 130091.0 +277 130091.0 +427 130091.0 +35 130091.0 +280 130091.0 +4 130091.0 +72 130091.0 +47 130091.0 +92 130091.0 +221 130091.0 +378 130091.0 +489 130091.0 +20 130091.0 +345 130091.0 +438 130091.0 +205 130091.0 +302 130091.0 +57 130091.0 +316 130091.0 +311 130091.0 +455 130091.0 +339 130091.0 +203 130091.0 +475 130091.0 +325 130091.0 +367 130091.0 +342 130091.0 +439 130091.0 +266 130091.0 +365 130091.0 +309 130091.0 +397 130091.0 +377 130091.0 +489 130091.0 +417 130091.0 +247 130091.0 +396 130091.0 +399 130091.0 +208 130091.0 +466 130091.0 +207 130091.0 +494 130091.0 +413 130091.0 +482 130091.0 +237 130091.0 +394 130091.0 +459 130091.0 +446 130091.0 +338 130091.0 +287 130091.0 +219 130091.0 +292 130091.0 +252 130091.0 +430 130091.0 +417 130091.0 +403 130091.0 +82 130091.0 +209 130091.0 +277 130091.0 +281 130091.0 +327 130091.0 +37 130091.0 +495 130091.0 +469 130091.0 +374 130091.0 +429 130091.0 +406 130091.0 +213 130091.0 +66 130091.0 +369 130091.0 +224 130091.0 +273 130091.0 +401 130091.0 +265 130091.0 +484 130091.0 +98 130091.0 +278 130091.0 +255 130091.0 +409 130091.0 +27 130091.0 +311 130091.0 +86 130091.0 +238 130091.0 +PREHOOK: query: -- Test predicate is not getting pushed down when predicate involves more than one col +select * from (SELECT key, value, sum(key) over(partition by key, value) as c1 from src)r1 where (key + value) > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: -- Test predicate is not getting pushed down when predicate involves more than one col +select * from (SELECT key, value, sum(key) over(partition by key, value) as c1 from src)r1 where (key + value) > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +PREHOOK: query: select * from (SELECT key, value, sum(key) over(partition by key + value) as c1 from src)r1 where (key + value) > '2' +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT key, value, sum(key) over(partition by key + value) as c1 from src)r1 where (key + value) > '2' +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### +PREHOOK: query: select * from (SELECT (cast(key as int))+(cast(value as int)) as key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +PREHOOK: type: QUERY +PREHOOK: Input: default@src +#### A masked pattern was here #### +POSTHOOK: query: select * from (SELECT (cast(key as int))+(cast(value as int)) as key, sum(key) over(partition by key) as c1 from src)r1 where key > 2 +POSTHOOK: type: QUERY +POSTHOOK: Input: default@src +#### A masked pattern was here #### diff --git a/ql/src/test/results/clientpositive/ptfgroupbyjoin.q.out b/ql/src/test/results/clientpositive/ptfgroupbyjoin.q.out index b726320..34889a4 100644 --- a/ql/src/test/results/clientpositive/ptfgroupbyjoin.q.out +++ b/ql/src/test/results/clientpositive/ptfgroupbyjoin.q.out @@ -76,9 +76,8 @@ STAGE PLANS: TableScan alias: tlb1 Statistics: Num rows: 2 Data size: 18 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: id (type: int), fkey (type: int) - outputColumnNames: id, fkey + Filter Operator + predicate: fkey is not null (type: boolean) Statistics: Num rows: 2 Data size: 18 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: id (type: int), fkey (type: int) @@ -96,15 +95,12 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: _col1 is not null (type: boolean) - Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + 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 @@ -213,9 +209,8 @@ STAGE PLANS: TableScan alias: tlb1 Statistics: Num rows: 2 Data size: 18 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: id (type: int), fkey (type: int) - outputColumnNames: id, fkey + Filter Operator + predicate: fkey is not null (type: boolean) Statistics: Num rows: 2 Data size: 18 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: id (type: int), fkey (type: int) @@ -253,19 +248,16 @@ STAGE PLANS: window frame: PRECEDING(MAX)~FOLLOWING(MAX) isPivotResult: true Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: _col1 is not null (type: boolean) + Select Operator + expressions: _col0 (type: int), _col1 (type: int), row_number_window_0 (type: int) + outputColumnNames: _col0, _col1, _col2 Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col0 (type: int), _col1 (type: int), row_number_window_0 (type: int) - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + 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 @@ -374,9 +366,8 @@ STAGE PLANS: TableScan alias: tlb1 Statistics: Num rows: 2 Data size: 18 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: id (type: int), fkey (type: int) - outputColumnNames: id, fkey + Filter Operator + predicate: fkey is not null (type: boolean) Statistics: Num rows: 2 Data size: 18 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: id (type: int), fkey (type: int) @@ -394,15 +385,12 @@ STAGE PLANS: mode: mergepartial outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: _col1 is not null (type: boolean) - Statistics: Num rows: 1 Data size: 9 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe + 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 diff --git a/ql/src/test/results/clientpositive/subquery_in.q.out b/ql/src/test/results/clientpositive/subquery_in.q.out index 0bbefc2..b235071 100644 --- a/ql/src/test/results/clientpositive/subquery_in.q.out +++ b/ql/src/test/results/clientpositive/subquery_in.q.out @@ -424,8 +424,7 @@ from part b where b.p_size in POSTHOOK: type: QUERY STAGE DEPENDENCIES: Stage-2 is a root stage - Stage-3 depends on stages: Stage-2 - Stage-1 depends on stages: Stage-3 + Stage-1 depends on stages: Stage-2 Stage-0 depends on stages: Stage-1 STAGE PLANS: @@ -435,87 +434,40 @@ STAGE PLANS: TableScan alias: b Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: p_mfgr (type: string), p_size (type: int) - sort order: ++ - Map-reduce partition columns: p_mfgr (type: string) - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - Reduce Operator Tree: - Select Operator - expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: int) - outputColumnNames: _col2, _col5 - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - PTF Operator - Function definitions: - Input definition - input alias: ptf_0 - output shape: _col2: string, _col5: int - type: WINDOWING - Windowing table definition - input alias: ptf_1 - name: windowingtablefunction - order by: _col5 - partition by: _col2 - raw input shape: - window functions: - window function definition - alias: rank_window_0 - arguments: _col5 - name: rank - window function: GenericUDAFRankEvaluator - window frame: PRECEDING(MAX)~FOLLOWING(MAX) - isPivotResult: true - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((rank_window_0 <= 2) and _col2 is not null) (type: boolean) - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col5 (type: int) + predicate: p_mfgr is not null (type: boolean) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: min(p_size) + keys: p_mfgr (type: string) + mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: min(_col1) - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - - Stage: Stage-3 - Map Reduce - Map Operator Tree: - TableScan - Reduce Output Operator - key expressions: _col0 (type: string) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - value expressions: _col1 (type: int) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: int) Reduce Operator Tree: Group By Operator aggregations: min(VALUE._col0) keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: _col1 is not null (type: boolean) - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: int), _col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: _col0 (type: int), _col1 (type: string) mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -547,7 +499,7 @@ STAGE PLANS: key expressions: _col0 (type: int), _col1 (type: string) sort order: ++ Map-reduce partition columns: _col0 (type: int), _col1 (type: string) - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Join Operator condition map: diff --git a/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out b/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out index 4cc5424..c03571f 100644 --- a/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out +++ b/ql/src/test/results/clientpositive/subquery_unqualcolumnrefs.q.out @@ -196,8 +196,7 @@ from part b where b.p_size in POSTHOOK: type: QUERY STAGE DEPENDENCIES: Stage-2 is a root stage - Stage-3 depends on stages: Stage-2 - Stage-1 depends on stages: Stage-3 + Stage-1 depends on stages: Stage-2 Stage-0 depends on stages: Stage-1 STAGE PLANS: @@ -207,68 +206,21 @@ STAGE PLANS: TableScan alias: part2 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Reduce Output Operator - key expressions: p2_mfgr (type: string), p2_size (type: int) - sort order: ++ - Map-reduce partition columns: p2_mfgr (type: string) - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - TopN Hash Memory Usage: 0.1 - Reduce Operator Tree: - Select Operator - expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: int) - outputColumnNames: _col2, _col5 - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - PTF Operator - Function definitions: - Input definition - input alias: ptf_0 - output shape: _col2: string, _col5: int - type: WINDOWING - Windowing table definition - input alias: ptf_1 - name: windowingtablefunction - order by: _col5 - partition by: _col2 - raw input shape: - window functions: - window function definition - alias: rank_window_0 - arguments: _col5 - name: rank - window function: GenericUDAFRankEvaluator - window frame: PRECEDING(MAX)~FOLLOWING(MAX) - isPivotResult: true - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE Filter Operator - predicate: ((rank_window_0 <= 2) and _col2 is not null) (type: boolean) + predicate: p2_mfgr is not null (type: boolean) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col5 (type: int) + Group By Operator + aggregations: min(p2_size) + keys: p2_mfgr (type: string) + mode: hash outputColumnNames: _col0, _col1 Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - Group By Operator - aggregations: min(_col1) - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0, _col1 + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - 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) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 1 Data size: 0 Basic stats: PARTIAL Column stats: NONE - value expressions: _col1 (type: int) + value expressions: _col1 (type: int) Reduce Operator Tree: Group By Operator aggregations: min(VALUE._col0) @@ -365,8 +317,7 @@ from part b where b.p_size in POSTHOOK: type: QUERY STAGE DEPENDENCIES: Stage-2 is a root stage - Stage-3 depends on stages: Stage-2 - Stage-1 depends on stages: Stage-3 + Stage-1 depends on stages: Stage-2 Stage-0 depends on stages: Stage-1 STAGE PLANS: @@ -376,87 +327,40 @@ STAGE PLANS: TableScan alias: b Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: p_mfgr (type: string), p_size (type: int) - sort order: ++ - Map-reduce partition columns: p_mfgr (type: string) - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 - Reduce Operator Tree: - Select Operator - expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: int) - outputColumnNames: _col2, _col5 - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - PTF Operator - Function definitions: - Input definition - input alias: ptf_0 - output shape: _col2: string, _col5: int - type: WINDOWING - Windowing table definition - input alias: ptf_1 - name: windowingtablefunction - order by: _col5 - partition by: _col2 - raw input shape: - window functions: - window function definition - alias: rank_window_0 - arguments: _col5 - name: rank - window function: GenericUDAFRankEvaluator - window frame: PRECEDING(MAX)~FOLLOWING(MAX) - isPivotResult: true - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE Filter Operator - predicate: ((rank_window_0 <= 2) and _col2 is not null) (type: boolean) - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col5 (type: int) + predicate: p_mfgr is not null (type: boolean) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: min(p_size) + keys: p_mfgr (type: string) + mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: min(_col1) - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - File Output Operator - compressed: false - table: - input format: org.apache.hadoop.mapred.SequenceFileInputFormat - output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat - serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe - - Stage: Stage-3 - Map Reduce - Map Operator Tree: - TableScan - Reduce Output Operator - key expressions: _col0 (type: string) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - value expressions: _col1 (type: int) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: int) Reduce Operator Tree: Group By Operator aggregations: min(VALUE._col0) keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: _col1 is not null (type: boolean) - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: int), _col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: _col0 (type: int), _col1 (type: string) mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false table: @@ -488,7 +392,7 @@ STAGE PLANS: key expressions: _col0 (type: int), _col1 (type: string) sort order: ++ Map-reduce partition columns: _col0 (type: int), _col1 (type: string) - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Reduce Operator Tree: Join Operator condition map: diff --git a/ql/src/test/results/clientpositive/tez/subquery_in.q.out b/ql/src/test/results/clientpositive/tez/subquery_in.q.out index 2c04009..3bf0e1c 100644 --- a/ql/src/test/results/clientpositive/tez/subquery_in.q.out +++ b/ql/src/test/results/clientpositive/tez/subquery_in.q.out @@ -437,9 +437,8 @@ STAGE PLANS: Tez #### A masked pattern was here #### Edges: - Reducer 2 <- Map 1 (SIMPLE_EDGE), Reducer 5 (SIMPLE_EDGE) + Reducer 2 <- Map 1 (SIMPLE_EDGE), Reducer 4 (SIMPLE_EDGE) Reducer 4 <- Map 3 (SIMPLE_EDGE) - Reducer 5 <- Reducer 4 (SIMPLE_EDGE) #### A masked pattern was here #### Vertices: Map 1 @@ -465,12 +464,21 @@ STAGE PLANS: TableScan alias: b Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: p_mfgr (type: string), p_size (type: int) - sort order: ++ - Map-reduce partition columns: p_mfgr (type: string) + Filter Operator + predicate: p_mfgr is not null (type: boolean) Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - TopN Hash Memory Usage: 0.1 + Group By Operator + aggregations: min(p_size) + keys: p_mfgr (type: string) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: string) + sort order: + + Map-reduce partition columns: _col0 (type: string) + Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: int) Reducer 2 Reduce Operator Tree: Merge Join Operator @@ -494,75 +502,29 @@ STAGE PLANS: serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe Reducer 4 Reduce Operator Tree: - Select Operator - expressions: KEY.reducesinkkey0 (type: string), KEY.reducesinkkey1 (type: int) - outputColumnNames: _col2, _col5 - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - PTF Operator - Function definitions: - Input definition - input alias: ptf_0 - output shape: _col2: string, _col5: int - type: WINDOWING - Windowing table definition - input alias: ptf_1 - name: windowingtablefunction - order by: _col5 - partition by: _col2 - raw input shape: - window functions: - window function definition - alias: rank_window_0 - arguments: _col5 - name: rank - window function: GenericUDAFRankEvaluator - window frame: PRECEDING(MAX)~FOLLOWING(MAX) - isPivotResult: true - Statistics: Num rows: 26 Data size: 3147 Basic stats: COMPLETE Column stats: NONE - Filter Operator - predicate: ((rank_window_0 <= 2) and _col2 is not null) (type: boolean) - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Select Operator - expressions: _col2 (type: string), _col5 (type: int) - outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: min(_col1) - keys: _col0 (type: string) - mode: hash - outputColumnNames: _col0, _col1 - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: string) - sort order: + - Map-reduce partition columns: _col0 (type: string) - Statistics: Num rows: 8 Data size: 968 Basic stats: COMPLETE Column stats: NONE - value expressions: _col1 (type: int) - Reducer 5 - Reduce Operator Tree: Group By Operator aggregations: min(VALUE._col0) keys: KEY._col0 (type: string) mode: mergepartial outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Filter Operator predicate: _col1 is not null (type: boolean) - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: int), _col0 (type: string) outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Group By Operator keys: _col0 (type: int), _col1 (type: string) mode: hash outputColumnNames: _col0, _col1 - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int), _col1 (type: string) sort order: ++ Map-reduce partition columns: _col0 (type: int), _col1 (type: string) - Statistics: Num rows: 4 Data size: 484 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 13 Data size: 1573 Basic stats: COMPLETE Column stats: NONE Stage: Stage-0 Fetch Operator