HIVE-18979: Enable AggregateReduceFunctionsRule from Calcite (Jesus Camacho Rodriguez...
authorJesus Camacho Rodriguez <jcamacho@apache.org>
Fri, 16 Mar 2018 19:09:22 +0000 (12:09 -0700)
committerJesus Camacho Rodriguez <jcamacho@apache.org>
Thu, 22 Mar 2018 16:55:42 +0000 (09:55 -0700)
207 files changed:
ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/functions/HiveSqlVarianceAggFunction.java [new file with mode: 0644]
ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateReduceFunctionsRule.java [new file with mode: 0644]
ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/translator/SqlFunctionConverter.java
ql/src/java/org/apache/hadoop/hive/ql/parse/CalcitePlanner.java
ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSumEmptyIsZero.java
ql/src/test/queries/clientpositive/groupby3.q
ql/src/test/queries/clientpositive/groupby3_map_skew.q
ql/src/test/queries/clientpositive/udaf_binarysetfunctions_no_cbo.q [new file with mode: 0644]
ql/src/test/results/clientpositive/cbo_rp_groupby3_noskew_multi_distinct.q.out
ql/src/test/results/clientpositive/count_dist_rewrite.q.out
ql/src/test/results/clientpositive/decimal_precision.q.out
ql/src/test/results/clientpositive/decimal_udf.q.out
ql/src/test/results/clientpositive/fetch_aggregation.q.out
ql/src/test/results/clientpositive/groupby3.q.out
ql/src/test/results/clientpositive/groupby3_map.q.out
ql/src/test/results/clientpositive/groupby3_map_multi_distinct.q.out
ql/src/test/results/clientpositive/groupby3_map_skew.q.out
ql/src/test/results/clientpositive/groupby3_noskew.q.out
ql/src/test/results/clientpositive/groupby3_noskew_multi_distinct.q.out
ql/src/test/results/clientpositive/groupby_grouping_sets3.q.out
ql/src/test/results/clientpositive/having2.q.out
ql/src/test/results/clientpositive/limit_pushdown2.q.out
ql/src/test/results/clientpositive/llap/count_dist_rewrite.q.out
ql/src/test/results/clientpositive/llap/explainuser_1.q.out
ql/src/test/results/clientpositive/llap/groupby3.q.out
ql/src/test/results/clientpositive/llap/limit_pushdown.q.out
ql/src/test/results/clientpositive/llap/limit_pushdown3.q.out
ql/src/test/results/clientpositive/llap/offset_limit_ppd_optimizer.q.out
ql/src/test/results/clientpositive/llap/parquet_types_vectorization.q.out
ql/src/test/results/clientpositive/llap/subquery_in.q.out
ql/src/test/results/clientpositive/llap/subquery_in_having.q.out
ql/src/test/results/clientpositive/llap/subquery_multi.q.out
ql/src/test/results/clientpositive/llap/subquery_notin.q.out
ql/src/test/results/clientpositive/llap/subquery_scalar.q.out
ql/src/test/results/clientpositive/llap/subquery_select.q.out
ql/src/test/results/clientpositive/llap/vector_aggregate_9.q.out
ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out
ql/src/test/results/clientpositive/llap/vector_decimal_aggregate.q.out
ql/src/test/results/clientpositive/llap/vector_decimal_precision.q.out
ql/src/test/results/clientpositive/llap/vector_decimal_udf.q.out
ql/src/test/results/clientpositive/llap/vector_groupby_grouping_sets3.q.out
ql/src/test/results/clientpositive/llap/vector_groupby_grouping_sets3_dec.q.out
ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out
ql/src/test/results/clientpositive/llap/vector_ptf_1.q.out
ql/src/test/results/clientpositive/llap/vector_reuse_scratchcols.q.out
ql/src/test/results/clientpositive/llap/vector_windowing.q.out
ql/src/test/results/clientpositive/llap/vectorization_0.q.out
ql/src/test/results/clientpositive/llap/vectorization_1.q.out
ql/src/test/results/clientpositive/llap/vectorization_12.q.out
ql/src/test/results/clientpositive/llap/vectorization_13.q.out
ql/src/test/results/clientpositive/llap/vectorization_14.q.out
ql/src/test/results/clientpositive/llap/vectorization_15.q.out
ql/src/test/results/clientpositive/llap/vectorization_16.q.out
ql/src/test/results/clientpositive/llap/vectorization_2.q.out
ql/src/test/results/clientpositive/llap/vectorization_3.q.out
ql/src/test/results/clientpositive/llap/vectorization_4.q.out
ql/src/test/results/clientpositive/llap/vectorization_9.q.out
ql/src/test/results/clientpositive/llap/vectorization_input_format_excludes.q.out
ql/src/test/results/clientpositive/llap/vectorization_not.q.out
ql/src/test/results/clientpositive/llap/vectorization_pushdown.q.out
ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out
ql/src/test/results/clientpositive/llap/vectorized_mapjoin.q.out
ql/src/test/results/clientpositive/llap/vectorized_parquet.q.out
ql/src/test/results/clientpositive/llap/vectorized_parquet_types.q.out
ql/src/test/results/clientpositive/llap/vectorized_shufflejoin.q.out
ql/src/test/results/clientpositive/llap/vectorized_timestamp.q.out
ql/src/test/results/clientpositive/llap/vectorized_timestamp_funcs.q.out
ql/src/test/results/clientpositive/parquet_types_non_dictionary_encoding_vectorization.q.out
ql/src/test/results/clientpositive/parquet_types_vectorization.q.out
ql/src/test/results/clientpositive/parquet_vectorization_0.q.out
ql/src/test/results/clientpositive/parquet_vectorization_1.q.out
ql/src/test/results/clientpositive/parquet_vectorization_12.q.out
ql/src/test/results/clientpositive/parquet_vectorization_13.q.out
ql/src/test/results/clientpositive/parquet_vectorization_14.q.out
ql/src/test/results/clientpositive/parquet_vectorization_15.q.out
ql/src/test/results/clientpositive/parquet_vectorization_16.q.out
ql/src/test/results/clientpositive/parquet_vectorization_2.q.out
ql/src/test/results/clientpositive/parquet_vectorization_3.q.out
ql/src/test/results/clientpositive/parquet_vectorization_4.q.out
ql/src/test/results/clientpositive/parquet_vectorization_9.q.out
ql/src/test/results/clientpositive/parquet_vectorization_limit.q.out
ql/src/test/results/clientpositive/parquet_vectorization_not.q.out
ql/src/test/results/clientpositive/parquet_vectorization_pushdown.q.out
ql/src/test/results/clientpositive/perf/spark/query1.q.out
ql/src/test/results/clientpositive/perf/spark/query13.q.out
ql/src/test/results/clientpositive/perf/spark/query17.q.out
ql/src/test/results/clientpositive/perf/spark/query18.q.out
ql/src/test/results/clientpositive/perf/spark/query22.q.out
ql/src/test/results/clientpositive/perf/spark/query24.q.out
ql/src/test/results/clientpositive/perf/spark/query26.q.out
ql/src/test/results/clientpositive/perf/spark/query27.q.out
ql/src/test/results/clientpositive/perf/spark/query28.q.out
ql/src/test/results/clientpositive/perf/spark/query30.q.out
ql/src/test/results/clientpositive/perf/spark/query32.q.out
ql/src/test/results/clientpositive/perf/spark/query35.q.out
ql/src/test/results/clientpositive/perf/spark/query39.q.out
ql/src/test/results/clientpositive/perf/spark/query44.q.out
ql/src/test/results/clientpositive/perf/spark/query6.q.out
ql/src/test/results/clientpositive/perf/spark/query65.q.out
ql/src/test/results/clientpositive/perf/spark/query7.q.out
ql/src/test/results/clientpositive/perf/spark/query81.q.out
ql/src/test/results/clientpositive/perf/spark/query85.q.out
ql/src/test/results/clientpositive/perf/spark/query9.q.out
ql/src/test/results/clientpositive/perf/spark/query92.q.out
ql/src/test/results/clientpositive/perf/tez/query1.q.out
ql/src/test/results/clientpositive/perf/tez/query13.q.out
ql/src/test/results/clientpositive/perf/tez/query14.q.out
ql/src/test/results/clientpositive/perf/tez/query17.q.out
ql/src/test/results/clientpositive/perf/tez/query18.q.out
ql/src/test/results/clientpositive/perf/tez/query22.q.out
ql/src/test/results/clientpositive/perf/tez/query24.q.out
ql/src/test/results/clientpositive/perf/tez/query26.q.out
ql/src/test/results/clientpositive/perf/tez/query27.q.out
ql/src/test/results/clientpositive/perf/tez/query28.q.out
ql/src/test/results/clientpositive/perf/tez/query30.q.out
ql/src/test/results/clientpositive/perf/tez/query32.q.out
ql/src/test/results/clientpositive/perf/tez/query35.q.out
ql/src/test/results/clientpositive/perf/tez/query39.q.out
ql/src/test/results/clientpositive/perf/tez/query44.q.out
ql/src/test/results/clientpositive/perf/tez/query6.q.out
ql/src/test/results/clientpositive/perf/tez/query65.q.out
ql/src/test/results/clientpositive/perf/tez/query7.q.out
ql/src/test/results/clientpositive/perf/tez/query81.q.out
ql/src/test/results/clientpositive/perf/tez/query85.q.out
ql/src/test/results/clientpositive/perf/tez/query9.q.out
ql/src/test/results/clientpositive/perf/tez/query92.q.out
ql/src/test/results/clientpositive/spark/dynamic_rdd_cache.q.out
ql/src/test/results/clientpositive/spark/groupby3.q.out
ql/src/test/results/clientpositive/spark/groupby3_map.q.out
ql/src/test/results/clientpositive/spark/groupby3_map_multi_distinct.q.out
ql/src/test/results/clientpositive/spark/groupby3_map_skew.q.out
ql/src/test/results/clientpositive/spark/groupby3_noskew.q.out
ql/src/test/results/clientpositive/spark/groupby3_noskew_multi_distinct.q.out
ql/src/test/results/clientpositive/spark/limit_pushdown.q.out
ql/src/test/results/clientpositive/spark/limit_pushdown2.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_0.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_1.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_12.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_13.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_14.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_15.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_16.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_2.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_3.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_4.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_9.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_limit.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_not.q.out
ql/src/test/results/clientpositive/spark/parquet_vectorization_pushdown.q.out
ql/src/test/results/clientpositive/spark/spark_explainuser_1.q.out
ql/src/test/results/clientpositive/spark/subquery_in.q.out
ql/src/test/results/clientpositive/spark/subquery_multi.q.out
ql/src/test/results/clientpositive/spark/subquery_notin.q.out
ql/src/test/results/clientpositive/spark/subquery_select.q.out
ql/src/test/results/clientpositive/spark/union_remove_6_subq.q.out
ql/src/test/results/clientpositive/spark/vector_cast_constant.q.out
ql/src/test/results/clientpositive/spark/vector_decimal_aggregate.q.out
ql/src/test/results/clientpositive/spark/vectorization_0.q.out
ql/src/test/results/clientpositive/spark/vectorization_1.q.out
ql/src/test/results/clientpositive/spark/vectorization_12.q.out
ql/src/test/results/clientpositive/spark/vectorization_13.q.out
ql/src/test/results/clientpositive/spark/vectorization_14.q.out
ql/src/test/results/clientpositive/spark/vectorization_15.q.out
ql/src/test/results/clientpositive/spark/vectorization_16.q.out
ql/src/test/results/clientpositive/spark/vectorization_2.q.out
ql/src/test/results/clientpositive/spark/vectorization_3.q.out
ql/src/test/results/clientpositive/spark/vectorization_4.q.out
ql/src/test/results/clientpositive/spark/vectorization_9.q.out
ql/src/test/results/clientpositive/spark/vectorization_input_format_excludes.q.out
ql/src/test/results/clientpositive/spark/vectorization_not.q.out
ql/src/test/results/clientpositive/spark/vectorization_pushdown.q.out
ql/src/test/results/clientpositive/spark/vectorization_short_regress.q.out
ql/src/test/results/clientpositive/spark/vectorized_mapjoin.q.out
ql/src/test/results/clientpositive/spark/vectorized_shufflejoin.q.out
ql/src/test/results/clientpositive/spark/vectorized_timestamp_funcs.q.out
ql/src/test/results/clientpositive/tez/vectorization_limit.q.out
ql/src/test/results/clientpositive/udaf_binarysetfunctions.q.out
ql/src/test/results/clientpositive/udaf_binarysetfunctions_no_cbo.q.out [new file with mode: 0644]
ql/src/test/results/clientpositive/udaf_number_format.q.out
ql/src/test/results/clientpositive/udf3.q.out
ql/src/test/results/clientpositive/udf8.q.out
ql/src/test/results/clientpositive/union_remove_6_subq.q.out
ql/src/test/results/clientpositive/vector_aggregate_9.q.out
ql/src/test/results/clientpositive/vector_cast_constant.q.out
ql/src/test/results/clientpositive/vector_decimal_aggregate.q.out
ql/src/test/results/clientpositive/vector_decimal_precision.q.out
ql/src/test/results/clientpositive/vector_groupby_reduce.q.out
ql/src/test/results/clientpositive/vectorization_1.q.out
ql/src/test/results/clientpositive/vectorization_12.q.out
ql/src/test/results/clientpositive/vectorization_13.q.out
ql/src/test/results/clientpositive/vectorization_14.q.out
ql/src/test/results/clientpositive/vectorization_15.q.out
ql/src/test/results/clientpositive/vectorization_16.q.out
ql/src/test/results/clientpositive/vectorization_2.q.out
ql/src/test/results/clientpositive/vectorization_3.q.out
ql/src/test/results/clientpositive/vectorization_4.q.out
ql/src/test/results/clientpositive/vectorization_9.q.out
ql/src/test/results/clientpositive/vectorization_limit.q.out
ql/src/test/results/clientpositive/vectorization_not.q.out
ql/src/test/results/clientpositive/vectorization_pushdown.q.out
ql/src/test/results/clientpositive/vectorized_distinct_gby.q.out
ql/src/test/results/clientpositive/vectorized_mapjoin.q.out
ql/src/test/results/clientpositive/vectorized_parquet_types.q.out
ql/src/test/results/clientpositive/vectorized_shufflejoin.q.out
ql/src/test/results/clientpositive/vectorized_timestamp.q.out
ql/src/test/results/clientpositive/vectorized_timestamp_funcs.q.out
ql/src/test/results/clientpositive/view_cbo.q.out

diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/functions/HiveSqlVarianceAggFunction.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/functions/HiveSqlVarianceAggFunction.java
new file mode 100644 (file)
index 0000000..9298e51
--- /dev/null
@@ -0,0 +1,39 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hive.ql.optimizer.calcite.functions;
+
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlFunctionCategory;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.type.SqlOperandTypeChecker;
+import org.apache.calcite.sql.type.SqlOperandTypeInference;
+import org.apache.calcite.sql.type.SqlReturnTypeInference;
+
+/**
+ * Aggregation function to represent: stddev_pop, stddev_samp, var_pop, var_samp.
+ */
+public class HiveSqlVarianceAggFunction extends SqlAggFunction {
+
+  public HiveSqlVarianceAggFunction(String name, SqlKind kind, SqlReturnTypeInference returnTypeInference,
+      SqlOperandTypeInference operandTypeInference, SqlOperandTypeChecker operandTypeChecker) {
+    super(name, null, kind, returnTypeInference, operandTypeInference,
+        operandTypeChecker, SqlFunctionCategory.NUMERIC, false, false);
+    assert kind == SqlKind.STDDEV_POP || kind == SqlKind.STDDEV_SAMP ||
+        kind == SqlKind.VAR_POP || kind == SqlKind.VAR_SAMP;
+  }
+
+}
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateReduceFunctionsRule.java b/ql/src/java/org/apache/hadoop/hive/ql/optimizer/calcite/rules/HiveAggregateReduceFunctionsRule.java
new file mode 100644 (file)
index 0000000..fb65ce1
--- /dev/null
@@ -0,0 +1,535 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.hadoop.hive.ql.optimizer.calcite.rules;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.apache.calcite.plan.RelOptCluster;
+import org.apache.calcite.plan.RelOptRule;
+import org.apache.calcite.plan.RelOptRuleCall;
+import org.apache.calcite.rel.RelNode;
+import org.apache.calcite.rel.core.Aggregate;
+import org.apache.calcite.rel.core.AggregateCall;
+import org.apache.calcite.rel.type.RelDataType;
+import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.rel.type.RelDataTypeField;
+import org.apache.calcite.rex.RexBuilder;
+import org.apache.calcite.rex.RexLiteral;
+import org.apache.calcite.rex.RexNode;
+import org.apache.calcite.sql.SqlAggFunction;
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.fun.SqlStdOperatorTable;
+import org.apache.calcite.sql.type.ReturnTypes;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.sql.type.SqlTypeUtil;
+import org.apache.calcite.tools.RelBuilder;
+import org.apache.calcite.util.CompositeList;
+import org.apache.calcite.util.ImmutableIntList;
+import org.apache.calcite.util.Util;
+import org.apache.hadoop.hive.ql.optimizer.calcite.HiveRelFactories;
+import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlCountAggFunction;
+import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlSumAggFunction;
+import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveAggregate;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This rule is a copy of {@link org.apache.calcite.rel.rules.AggregateReduceFunctionsRule}
+ * that regenerates Hive specific aggregate operators.
+ *
+ * TODO: When CALCITE-2216 is completed, we should be able to remove much of this code and
+ * just override the relevant methods.
+ *
+ * Planner rule that reduces aggregate functions in
+ * {@link org.apache.calcite.rel.core.Aggregate}s to simpler forms.
+ *
+ * <p>Rewrites:
+ * <ul>
+ *
+ * <li>AVG(x) &rarr; SUM(x) / COUNT(x)
+ *
+ * <li>STDDEV_POP(x) &rarr; SQRT(
+ *     (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ *    / COUNT(x))
+ *
+ * <li>STDDEV_SAMP(x) &rarr; SQRT(
+ *     (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ *     / CASE COUNT(x) WHEN 1 THEN NULL ELSE COUNT(x) - 1 END)
+ *
+ * <li>VAR_POP(x) &rarr; (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ *     / COUNT(x)
+ *
+ * <li>VAR_SAMP(x) &rarr; (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+ *        / CASE COUNT(x) WHEN 1 THEN NULL ELSE COUNT(x) - 1 END
+ * </ul>
+ */
+public class HiveAggregateReduceFunctionsRule extends RelOptRule {
+  //~ Static fields/initializers ---------------------------------------------
+
+  /** The singleton. */
+  public static final HiveAggregateReduceFunctionsRule INSTANCE =
+      new HiveAggregateReduceFunctionsRule();
+
+  //~ Constructors -----------------------------------------------------------
+
+  /** Creates an HiveAggregateReduceFunctionsRule. */
+  public HiveAggregateReduceFunctionsRule() {
+    super(operand(HiveAggregate.class, any()),
+        HiveRelFactories.HIVE_BUILDER, null);
+  }
+
+  //~ Methods ----------------------------------------------------------------
+
+  @Override public boolean matches(RelOptRuleCall call) {
+    if (!super.matches(call)) {
+      return false;
+    }
+    Aggregate oldAggRel = (Aggregate) call.rels[0];
+    return containsAvgStddevVarCall(oldAggRel.getAggCallList());
+  }
+
+  public void onMatch(RelOptRuleCall ruleCall) {
+    Aggregate oldAggRel = (Aggregate) ruleCall.rels[0];
+    reduceAggs(ruleCall, oldAggRel);
+  }
+
+  /**
+   * Returns whether any of the aggregates are calls to AVG, STDDEV_*, VAR_*.
+   *
+   * @param aggCallList List of aggregate calls
+   */
+  private boolean containsAvgStddevVarCall(List<AggregateCall> aggCallList) {
+    for (AggregateCall call : aggCallList) {
+      if (isReducible(call.getAggregation().getKind())) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Returns whether the aggregate call is a reducible function
+   */
+  private boolean isReducible(final SqlKind kind) {
+    if (SqlKind.AVG_AGG_FUNCTIONS.contains(kind)) {
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Reduces all calls to AVG, STDDEV_POP, STDDEV_SAMP, VAR_POP, VAR_SAMP in
+   * the aggregates list to.
+   *
+   * <p>It handles newly generated common subexpressions since this was done
+   * at the sql2rel stage.
+   */
+  private void reduceAggs(
+      RelOptRuleCall ruleCall,
+      Aggregate oldAggRel) {
+    RexBuilder rexBuilder = oldAggRel.getCluster().getRexBuilder();
+
+    List<AggregateCall> oldCalls = oldAggRel.getAggCallList();
+    final int groupCount = oldAggRel.getGroupCount();
+    final int indicatorCount = oldAggRel.getIndicatorCount();
+
+    final List<AggregateCall> newCalls = Lists.newArrayList();
+    final Map<AggregateCall, RexNode> aggCallMapping = Maps.newHashMap();
+
+    final List<RexNode> projList = Lists.newArrayList();
+
+    // pass through group key (+ indicators if present)
+    for (int i = 0; i < groupCount + indicatorCount; ++i) {
+      projList.add(
+          rexBuilder.makeInputRef(
+              getFieldType(oldAggRel, i),
+              i));
+    }
+
+    // List of input expressions. If a particular aggregate needs more, it
+    // will add an expression to the end, and we will create an extra
+    // project.
+    final RelBuilder relBuilder = ruleCall.builder();
+    relBuilder.push(oldAggRel.getInput());
+    final List<RexNode> inputExprs = new ArrayList<>(relBuilder.fields());
+
+    // create new agg function calls and rest of project list together
+    for (AggregateCall oldCall : oldCalls) {
+      projList.add(
+          reduceAgg(
+              oldAggRel, oldCall, newCalls, aggCallMapping, inputExprs));
+    }
+
+    final int extraArgCount =
+        inputExprs.size() - relBuilder.peek().getRowType().getFieldCount();
+    if (extraArgCount > 0) {
+      relBuilder.project(inputExprs,
+          CompositeList.of(
+              relBuilder.peek().getRowType().getFieldNames(),
+              Collections.<String>nCopies(extraArgCount, null)));
+    }
+    newAggregateRel(relBuilder, oldAggRel, newCalls);
+    relBuilder.project(projList, oldAggRel.getRowType().getFieldNames())
+        .convert(oldAggRel.getRowType(), false);
+    ruleCall.transformTo(relBuilder.build());
+  }
+
+  private RexNode reduceAgg(
+      Aggregate oldAggRel,
+      AggregateCall oldCall,
+      List<AggregateCall> newCalls,
+      Map<AggregateCall, RexNode> aggCallMapping,
+      List<RexNode> inputExprs) {
+    final SqlKind kind = oldCall.getAggregation().getKind();
+    if (isReducible(kind)) {
+      switch (kind) {
+      case AVG:
+        // replace original AVG(x) with SUM(x) / COUNT(x)
+        return reduceAvg(oldAggRel, oldCall, newCalls, aggCallMapping, inputExprs);
+      case STDDEV_POP:
+        // replace original STDDEV_POP(x) with
+        //   SQRT(
+        //     (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+        //     / COUNT(x))
+        return reduceStddev(oldAggRel, oldCall, true, true, newCalls,
+            aggCallMapping, inputExprs);
+      case STDDEV_SAMP:
+        // replace original STDDEV_SAMP(x) with
+        //   SQRT(
+        //     (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+        //     / CASE COUNT(x) WHEN 1 THEN NULL ELSE COUNT(x) - 1 END)
+        return reduceStddev(oldAggRel, oldCall, false, true, newCalls,
+            aggCallMapping, inputExprs);
+      case VAR_POP:
+        // replace original VAR_POP(x) with
+        //     (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+        //     / COUNT(x)
+        return reduceStddev(oldAggRel, oldCall, true, false, newCalls,
+            aggCallMapping, inputExprs);
+      case VAR_SAMP:
+        // replace original VAR_SAMP(x) with
+        //     (SUM(x * x) - SUM(x) * SUM(x) / COUNT(x))
+        //     / CASE COUNT(x) WHEN 1 THEN NULL ELSE COUNT(x) - 1 END
+        return reduceStddev(oldAggRel, oldCall, false, false, newCalls,
+            aggCallMapping, inputExprs);
+      default:
+        throw Util.unexpected(kind);
+      }
+    } else {
+      // anything else:  preserve original call
+      RexBuilder rexBuilder = oldAggRel.getCluster().getRexBuilder();
+      final int nGroups = oldAggRel.getGroupCount();
+      List<RelDataType> oldArgTypes =
+          SqlTypeUtil.projectTypes(
+              oldAggRel.getInput().getRowType(), oldCall.getArgList());
+      return rexBuilder.addAggCall(oldCall,
+          nGroups,
+          oldAggRel.indicator,
+          newCalls,
+          aggCallMapping,
+          oldArgTypes);
+    }
+  }
+
+  private AggregateCall createAggregateCallWithBinding(
+      RelDataTypeFactory typeFactory,
+      SqlAggFunction aggFunction,
+      RelDataType operandType,
+      Aggregate oldAggRel,
+      AggregateCall oldCall,
+      int argOrdinal) {
+    final Aggregate.AggCallBinding binding =
+        new Aggregate.AggCallBinding(typeFactory, aggFunction,
+            ImmutableList.of(operandType), oldAggRel.getGroupCount(),
+            oldCall.filterArg >= 0);
+    return AggregateCall.create(aggFunction,
+        oldCall.isDistinct(),
+        oldCall.isApproximate(),
+        ImmutableIntList.of(argOrdinal),
+        oldCall.filterArg,
+        aggFunction.inferReturnType(binding),
+        null);
+  }
+
+  private RexNode reduceAvg(
+      Aggregate oldAggRel,
+      AggregateCall oldCall,
+      List<AggregateCall> newCalls,
+      Map<AggregateCall, RexNode> aggCallMapping,
+      List<RexNode> inputExprs) {
+    final int nGroups = oldAggRel.getGroupCount();
+    final RexBuilder rexBuilder = oldAggRel.getCluster().getRexBuilder();
+    final RelDataTypeFactory typeFactory = oldAggRel.getCluster().getTypeFactory();
+    final int iAvgInput = oldCall.getArgList().get(0);
+    RelDataType avgInputType = typeFactory.createTypeWithNullability(
+        getFieldType(oldAggRel.getInput(), iAvgInput), true);
+    final AggregateCall sumCall =
+        AggregateCall.create(
+            new HiveSqlSumAggFunction(
+                oldCall.isDistinct(),
+                oldCall.getAggregation().getReturnTypeInference(),
+                oldCall.getAggregation().getOperandTypeInference(),
+                oldCall.getAggregation().getOperandTypeChecker()), //SqlStdOperatorTable.SUM,
+            oldCall.isDistinct(),
+            oldCall.isApproximate(),
+            oldCall.getArgList(),
+            oldCall.filterArg,
+            oldAggRel.getGroupCount(),
+            oldAggRel.getInput(),
+            null,
+            null);
+    RelDataType countRetType = typeFactory.createTypeWithNullability(
+        typeFactory.createSqlType(SqlTypeName.BIGINT), true);
+    final AggregateCall countCall =
+        AggregateCall.create(
+            new HiveSqlCountAggFunction(
+                oldCall.isDistinct(),
+                ReturnTypes.explicit(countRetType),
+                oldCall.getAggregation().getOperandTypeInference(),
+                oldCall.getAggregation().getOperandTypeChecker()), //SqlStdOperatorTable.COUNT,
+            oldCall.isDistinct(),
+            oldCall.isApproximate(),
+            oldCall.getArgList(),
+            oldCall.filterArg,
+            oldAggRel.getGroupCount(),
+            oldAggRel.getInput(),
+            countRetType,
+            null);
+
+    // NOTE:  these references are with respect to the output
+    // of newAggRel
+    RexNode numeratorRef =
+        rexBuilder.addAggCall(sumCall,
+            nGroups,
+            oldAggRel.indicator,
+            newCalls,
+            aggCallMapping,
+            ImmutableList.of(avgInputType));
+    final RexNode denominatorRef =
+        rexBuilder.addAggCall(countCall,
+            nGroups,
+            oldAggRel.indicator,
+            newCalls,
+            aggCallMapping,
+            ImmutableList.of(avgInputType));
+
+    numeratorRef = rexBuilder.ensureType(oldCall.getType(), numeratorRef, true);
+    final RexNode divideRef =
+        rexBuilder.makeCall(SqlStdOperatorTable.DIVIDE, numeratorRef, denominatorRef);
+    return rexBuilder.makeCast(oldCall.getType(), divideRef);
+  }
+
+  private RexNode reduceStddev(
+      Aggregate oldAggRel,
+      AggregateCall oldCall,
+      boolean biased,
+      boolean sqrt,
+      List<AggregateCall> newCalls,
+      Map<AggregateCall, RexNode> aggCallMapping,
+      List<RexNode> inputExprs) {
+    // stddev_pop(x) ==>
+    //   power(
+    //     (sum(x * x) - sum(x) * sum(x) / count(x))
+    //     / count(x),
+    //     .5)
+    //
+    // stddev_samp(x) ==>
+    //   power(
+    //     (sum(x * x) - sum(x) * sum(x) / count(x))
+    //     / nullif(count(x) - 1, 0),
+    //     .5)
+    final int nGroups = oldAggRel.getGroupCount();
+    final RelOptCluster cluster = oldAggRel.getCluster();
+    final RexBuilder rexBuilder = cluster.getRexBuilder();
+    final RelDataTypeFactory typeFactory = cluster.getTypeFactory();
+
+    assert oldCall.getArgList().size() == 1 : oldCall.getArgList();
+    final int argOrdinal = oldCall.getArgList().get(0);
+    final RelDataType argOrdinalType = getFieldType(oldAggRel.getInput(), argOrdinal);
+    final RelDataType oldCallType =
+        typeFactory.createTypeWithNullability(oldCall.getType(), true);
+
+    final RexNode argRef =
+        rexBuilder.ensureType(oldCallType, inputExprs.get(argOrdinal), false);
+    final int argRefOrdinal = lookupOrAdd(inputExprs, argRef);
+
+    final RexNode argSquared = rexBuilder.makeCall(SqlStdOperatorTable.MULTIPLY,
+        argRef, argRef);
+    final int argSquaredOrdinal = lookupOrAdd(inputExprs, argSquared);
+
+    final AggregateCall sumArgSquaredAggCall =
+        createAggregateCallWithBinding(typeFactory,
+            new HiveSqlSumAggFunction(
+                oldCall.isDistinct(),
+                oldCall.getAggregation().getReturnTypeInference(),
+                oldCall.getAggregation().getOperandTypeInference(),
+                oldCall.getAggregation().getOperandTypeChecker()), //SqlStdOperatorTable.SUM,
+            argSquared.getType(), oldAggRel, oldCall, argSquaredOrdinal);
+
+    final RexNode sumArgSquared =
+        rexBuilder.addAggCall(sumArgSquaredAggCall,
+            nGroups,
+            oldAggRel.indicator,
+            newCalls,
+            aggCallMapping,
+            ImmutableList.of(sumArgSquaredAggCall.getType()));
+
+    final AggregateCall sumArgAggCall =
+        AggregateCall.create(
+            new HiveSqlSumAggFunction(
+                oldCall.isDistinct(),
+                oldCall.getAggregation().getReturnTypeInference(),
+                oldCall.getAggregation().getOperandTypeInference(),
+                oldCall.getAggregation().getOperandTypeChecker()), //SqlStdOperatorTable.SUM,
+            oldCall.isDistinct(),
+            oldCall.isApproximate(),
+            ImmutableIntList.of(argRefOrdinal),
+            oldCall.filterArg,
+            oldAggRel.getGroupCount(),
+            oldAggRel.getInput(),
+            null,
+            null);
+
+    final RexNode sumArg =
+        rexBuilder.addAggCall(sumArgAggCall,
+            nGroups,
+            oldAggRel.indicator,
+            newCalls,
+            aggCallMapping,
+            ImmutableList.of(sumArgAggCall.getType()));
+    final RexNode sumArgCast = rexBuilder.ensureType(oldCallType, sumArg, true);
+    final RexNode sumSquaredArg =
+        rexBuilder.makeCall(
+            SqlStdOperatorTable.MULTIPLY, sumArgCast, sumArgCast);
+
+    RelDataType countRetType = typeFactory.createTypeWithNullability(typeFactory.createSqlType(SqlTypeName.BIGINT), true);
+    final AggregateCall countArgAggCall =
+        AggregateCall.create(
+            new HiveSqlCountAggFunction(
+                oldCall.isDistinct(),
+                ReturnTypes.explicit(countRetType),
+                oldCall.getAggregation().getOperandTypeInference(),
+                oldCall.getAggregation().getOperandTypeChecker()), //SqlStdOperatorTable.COUNT,
+            oldCall.isDistinct(),
+            oldCall.isApproximate(),
+            oldCall.getArgList(),
+            oldCall.filterArg,
+            oldAggRel.getGroupCount(),
+            oldAggRel.getInput(),
+            countRetType,
+            null);
+
+    final RexNode countArg =
+        rexBuilder.addAggCall(countArgAggCall,
+            nGroups,
+            oldAggRel.indicator,
+            newCalls,
+            aggCallMapping,
+            ImmutableList.of(argOrdinalType));
+
+    final RexNode avgSumSquaredArg =
+        rexBuilder.makeCall(
+            SqlStdOperatorTable.DIVIDE, sumSquaredArg, countArg);
+
+    final RexNode diff =
+        rexBuilder.makeCall(
+            SqlStdOperatorTable.MINUS,
+            sumArgSquared, avgSumSquaredArg);
+
+    final RexNode denominator;
+    if (biased) {
+      denominator = countArg;
+    } else {
+      final RexLiteral one =
+          rexBuilder.makeExactLiteral(BigDecimal.ONE);
+      final RexNode nul =
+          rexBuilder.makeCast(countArg.getType(), rexBuilder.constantNull());
+      final RexNode countMinusOne =
+          rexBuilder.makeCall(
+              SqlStdOperatorTable.MINUS, countArg, one);
+      final RexNode countEqOne =
+          rexBuilder.makeCall(
+              SqlStdOperatorTable.EQUALS, countArg, one);
+      denominator =
+          rexBuilder.makeCall(
+              SqlStdOperatorTable.CASE,
+              countEqOne, nul, countMinusOne);
+    }
+
+    final RexNode div =
+        rexBuilder.makeCall(
+            SqlStdOperatorTable.DIVIDE, diff, denominator);
+
+    RexNode result = div;
+    if (sqrt) {
+      final RexNode half =
+          rexBuilder.makeExactLiteral(new BigDecimal("0.5"));
+      result =
+          rexBuilder.makeCall(
+              SqlStdOperatorTable.POWER, div, half);
+    }
+
+    return rexBuilder.makeCast(
+        oldCall.getType(), result);
+  }
+
+  /**
+   * Finds the ordinal of an element in a list, or adds it.
+   *
+   * @param list    List
+   * @param element Element to lookup or add
+   * @return Ordinal of element in list
+   */
+  private static int lookupOrAdd(List<RexNode> list, RexNode element) {
+    for (int ordinal = 0; ordinal < list.size(); ordinal++) {
+      if (list.get(ordinal).toString().equals(element.toString())) {
+        return ordinal;
+      }
+    }
+    list.add(element);
+    return list.size() - 1;
+  }
+
+  /**
+   * Do a shallow clone of oldAggRel and update aggCalls. Could be refactored
+   * into Aggregate and subclasses - but it's only needed for some
+   * subclasses.
+   *
+   * @param relBuilder Builder of relational expressions; at the top of its
+   *                   stack is its input
+   * @param oldAggregate LogicalAggregate to clone.
+   * @param newCalls  New list of AggregateCalls
+   */
+  protected void newAggregateRel(RelBuilder relBuilder,
+      Aggregate oldAggregate, List<AggregateCall> newCalls) {
+    relBuilder.aggregate(
+        relBuilder.groupKey(oldAggregate.getGroupSet(),
+            oldAggregate.getGroupSets()),
+        newCalls);
+  }
+
+  private RelDataType getFieldType(RelNode relNode, int i) {
+    final RelDataTypeField inputField =
+        relNode.getRowType().getFieldList().get(i);
+    return inputField.getType();
+  }
+}
index cb0c2b1..950abe1 100644 (file)
@@ -49,6 +49,7 @@ import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlAverageAggFu
 import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlCountAggFunction;
 import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlMinMaxAggFunction;
 import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlSumAggFunction;
+import org.apache.hadoop.hive.ql.optimizer.calcite.functions.HiveSqlVarianceAggFunction;
 import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveBetween;
 import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveConcat;
 import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveExtractDate;
@@ -577,48 +578,82 @@ public class SqlFunctionConverter {
       CalciteUDFInfo udfInfo = getUDFInfo(hiveUdfName, calciteArgTypes, calciteRetType);
 
       switch (hiveUdfName.toLowerCase()) {
-        case "sum":
-          calciteAggFn = new HiveSqlSumAggFunction(
-              isDistinct,
-              udfInfo.returnTypeInference,
-              udfInfo.operandTypeInference,
-              udfInfo.operandTypeChecker);
-          break;
-        case "count":
-          calciteAggFn = new HiveSqlCountAggFunction(
-              isDistinct,
-              udfInfo.returnTypeInference,
-              udfInfo.operandTypeInference,
-              udfInfo.operandTypeChecker);
-          break;
-        case "min":
-          calciteAggFn = new HiveSqlMinMaxAggFunction(
-              udfInfo.returnTypeInference,
-              udfInfo.operandTypeInference,
-              udfInfo.operandTypeChecker, true);
-          break;
-        case "max":
-          calciteAggFn = new HiveSqlMinMaxAggFunction(
-              udfInfo.returnTypeInference,
-              udfInfo.operandTypeInference,
-              udfInfo.operandTypeChecker, false);
-          break;
-        case "avg":
-          calciteAggFn = new HiveSqlAverageAggFunction(
-              udfInfo.returnTypeInference,
-              udfInfo.operandTypeInference,
-              udfInfo.operandTypeChecker);
+      case "sum":
+        calciteAggFn = new HiveSqlSumAggFunction(
+            isDistinct,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      case "count":
+        calciteAggFn = new HiveSqlCountAggFunction(
+            isDistinct,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      case "min":
+        calciteAggFn = new HiveSqlMinMaxAggFunction(
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker, true);
+        break;
+      case "max":
+        calciteAggFn = new HiveSqlMinMaxAggFunction(
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker, false);
+        break;
+      case "avg":
+        calciteAggFn = new HiveSqlAverageAggFunction(
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      case "std":
+      case "stddev":
+      case "stddev_pop":
+        calciteAggFn = new HiveSqlVarianceAggFunction(
+            "stddev_pop",
+            SqlKind.STDDEV_POP,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      case "stddev_samp":
+        calciteAggFn = new HiveSqlVarianceAggFunction(
+            "stddev_samp",
+            SqlKind.STDDEV_SAMP,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      case "variance":
+      case "var_pop":
+        calciteAggFn = new HiveSqlVarianceAggFunction(
+            "var_pop",
+            SqlKind.VAR_POP,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      case "var_samp":
+        calciteAggFn = new HiveSqlVarianceAggFunction(
+            "var_samp",
+            SqlKind.VAR_SAMP,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
+        break;
+      default:
+        calciteAggFn = new CalciteUDAF(
+            isDistinct,
+            udfInfo.udfName,
+            udfInfo.returnTypeInference,
+            udfInfo.operandTypeInference,
+            udfInfo.operandTypeChecker);
         break;
-        default:
-          calciteAggFn = new CalciteUDAF(
-              isDistinct,
-              udfInfo.udfName,
-              udfInfo.returnTypeInference,
-              udfInfo.operandTypeInference,
-              udfInfo.operandTypeChecker);
-          break;
       }
-
     }
     return calciteAggFn;
   }
index 92e2f3b..75ddf5e 100644 (file)
@@ -177,6 +177,7 @@ import org.apache.hadoop.hive.ql.optimizer.calcite.reloperators.HiveUnion;
 import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveAggregateJoinTransposeRule;
 import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveAggregateProjectMergeRule;
 import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveAggregatePullUpConstantsRule;
+import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveAggregateReduceFunctionsRule;
 import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveAggregateReduceRule;
 import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveDruidRules;
 import org.apache.hadoop.hive.ql.optimizer.calcite.rules.HiveExceptRewriteRule;
@@ -1821,6 +1822,7 @@ public class CalcitePlanner extends SemanticAnalyzer {
       rules.add(HiveReduceExpressionsRule.PROJECT_INSTANCE);
       rules.add(HiveReduceExpressionsRule.FILTER_INSTANCE);
       rules.add(HiveReduceExpressionsRule.JOIN_INSTANCE);
+      rules.add(HiveAggregateReduceFunctionsRule.INSTANCE);
       rules.add(HiveAggregateReduceRule.INSTANCE);
       if (conf.getBoolVar(HiveConf.ConfVars.HIVEPOINTLOOKUPOPTIMIZER)) {
         rules.add(new HivePointLookupOptimizerRule.FilterCondition(minNumORClauses));
@@ -1839,7 +1841,7 @@ public class CalcitePlanner extends SemanticAnalyzer {
               rules.toArray(new RelOptRule[rules.size()]));
       perfLogger.PerfLogEnd(this.getClass().getName(), PerfLogger.OPTIMIZER,
         "Calcite: Prejoin ordering transformation, PPD, not null predicates, transitive inference, constant folding");
-// it is happening at 1762
+
       // 4. Push down limit through outer join
       // NOTE: We run this after PPD to support old style join syntax.
       // Ex: select * from R1 left outer join R2 where ((R1.x=R2.x) and R1.y<10) or
index 01c933c..a0072f7 100644 (file)
@@ -41,16 +41,30 @@ public class GenericUDAFSumEmptyIsZero extends GenericUDAFSum {
               + parameters[0].getTypeName() + " is passed.");
     }
     switch (((PrimitiveTypeInfo) parameters[0]).getPrimitiveCategory()) {
+    case BYTE:
+    case SHORT:
+    case INT:
     case LONG:
-      return new SumZeroIfEmpty();
+      return new SumLongZeroIfEmpty();
+    case TIMESTAMP:
+    case FLOAT:
+    case DOUBLE:
+    case STRING:
+    case VARCHAR:
+    case CHAR:
+      return new SumDoubleZeroIfEmpty();
+    case DECIMAL:
+      return new SumHiveDecimalZeroIfEmpty();
+    case BOOLEAN:
+    case DATE:
     default:
       throw new UDFArgumentTypeException(0,
-          "Only bigint type arguments are accepted but "
+          "Only numeric or string type arguments are accepted but "
               + parameters[0].getTypeName() + " is passed.");
     }
   }
 
-  public static class SumZeroIfEmpty extends GenericUDAFSumLong {
+  public static class SumLongZeroIfEmpty extends GenericUDAFSumLong {
 
     @Override
     public Object terminate(AggregationBuffer agg) throws HiveException {
@@ -59,5 +73,24 @@ public class GenericUDAFSumEmptyIsZero extends GenericUDAFSum {
       return result;
     }
   }
-}
 
+  public static class SumDoubleZeroIfEmpty extends GenericUDAFSumDouble {
+
+    @Override
+    public Object terminate(AggregationBuffer agg) throws HiveException {
+      SumDoubleAgg myagg = (SumDoubleAgg) agg;
+      result.set(myagg.sum);
+      return result;
+    }
+  }
+
+  public static class SumHiveDecimalZeroIfEmpty extends GenericUDAFSumHiveDecimal {
+
+    @Override
+    public Object terminate(AggregationBuffer agg) throws HiveException {
+      SumHiveDecimalWritableAgg myagg = (SumHiveDecimalWritableAgg) agg;
+      result.set(myagg.sum);
+      return result;
+    }
+  }
+}
index d709d9b..284c2a8 100755 (executable)
@@ -1,3 +1,4 @@
+set hive.cbo.enable=false;
 set hive.mapred.mode=nonstrict;
 set hive.explain.user=false;
 set hive.map.aggr=false;
index f9cb46e..8b18d11 100644 (file)
@@ -1,3 +1,4 @@
+set hive.cbo.enable=false;
 set hive.mapred.mode=nonstrict;
 set hive.map.aggr=true;
 set hive.groupby.skewindata=true;
diff --git a/ql/src/test/queries/clientpositive/udaf_binarysetfunctions_no_cbo.q b/ql/src/test/queries/clientpositive/udaf_binarysetfunctions_no_cbo.q
new file mode 100644 (file)
index 0000000..ae4733f
--- /dev/null
@@ -0,0 +1,60 @@
+set hive.cbo.enable=false;
+
+drop table t;
+create table t (id int,px int,y decimal,x decimal);
+
+insert into t values (101,1,1,1);
+insert into t values (201,2,1,1);
+insert into t values (301,3,1,1);
+insert into t values (401,4,1,11);
+insert into t values (501,5,1,null);
+insert into t values (601,6,null,1);
+insert into t values (701,6,null,null);
+insert into t values (102,1,2,2);
+insert into t values (202,2,1,2);
+insert into t values (302,3,2,1);
+insert into t values (402,4,2,12);
+insert into t values (502,5,2,null);
+insert into t values (602,6,null,2);
+insert into t values (702,6,null,null);
+insert into t values (103,1,3,3);
+insert into t values (203,2,1,3);
+insert into t values (303,3,3,1);
+insert into t values (403,4,3,13);
+insert into t values (503,5,3,null);
+insert into t values (603,6,null,3);
+insert into t values (703,6,null,null);
+insert into t values (104,1,4,4);
+insert into t values (204,2,1,4);
+insert into t values (304,3,4,1);
+insert into t values (404,4,4,14);
+insert into t values (504,5,4,null);
+insert into t values (604,6,null,4);
+insert into t values (704,6,null,null);
+insert into t values (800,7,1,1);
+
+
+explain select px,var_pop(x),var_pop(y),corr(y,x),covar_samp(y,x),covar_pop(y,x),regr_count(y,x),regr_slope(y,x),
+regr_intercept(y,x), regr_r2(y,x), regr_sxx(y,x), regr_syy(y,x), regr_sxy(y,x), regr_avgx(y,x), regr_avgy(y,x), regr_count(y,x)
+ from t group by px order by px;
+
+select px,
+       round(  var_pop(x),5),
+       round(  var_pop(y),5),
+       round(  corr(y,x),5),
+       round(  covar_samp(y,x),5),
+       round(  covar_pop(y,x),5),
+       regr_count(y,x),
+       round(  regr_slope(y,x),5),
+       round(  regr_intercept(y,x),5),
+       round(  regr_r2(y,x),5),
+       round(  regr_sxx(y,x),5),
+       round(  regr_syy(y,x),5),
+       round(  regr_sxy(y,x),5),
+       round(  regr_avgx(y,x),5),
+       round(  regr_avgy(y,x),5),
+       round(  regr_count(y,x),5)
+ from t group by px order by px;
+
+
+select id,regr_count(y,x) over (partition by px) from t order by id;
index bece89f..58e6f46 100644 (file)
@@ -49,26 +49,27 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: $f0
+              expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+              outputColumnNames: $f0, $f00, $f2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Reduce Output Operator
                 key expressions: $f0 (type: string)
                 sort order: +
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
+                value expressions: $f2 (type: double), $f00 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(KEY._col0:0._col0), avg(KEY._col0:0._col0), avg(DISTINCT KEY._col0:0._col0), max(KEY._col0:0._col0), min(KEY._col0:0._col0), std(KEY._col0:0._col0), stddev_samp(KEY._col0:0._col0), variance(KEY._col0:0._col0), var_samp(KEY._col0:0._col0), sum(DISTINCT KEY._col0:1._col0), count(DISTINCT KEY._col0:2._col0)
+          aggregations: sum(KEY._col0:0._col0), count(KEY._col0:0._col0), sum(DISTINCT KEY._col0:0._col0), count(DISTINCT KEY._col0:1._col0), max(KEY._col0:0._col0), min(KEY._col0:0._col0), sum(VALUE._col0), sum(VALUE._col1)
           mode: complete
-          outputColumnNames: $f0, $f1, $f2, $f3, $f4, $f5, $f6, $f7, $f8, $f9, $f10
-          Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: $f0, $f1, $f2, $f3, $f4, $f5, $f6, $f7
+          Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: $f0 (type: double), $f1 (type: double), $f2 (type: double), UDFToDouble($f3) (type: double), UDFToDouble($f4) (type: double), $f5 (type: double), $f6 (type: double), $f7 (type: double), $f8 (type: double), $f9 (type: double), UDFToDouble($f10) (type: double)
+            expressions: $f0 (type: double), ($f0 / $f1) (type: double), ($f2 / $f3) (type: double), UDFToDouble($f4) (type: double), UDFToDouble($f5) (type: double), power((($f6 - (($f7 * $f7) / $f1)) / $f1), 0.5) (type: double), power((($f6 - (($f7 * $f7) / $f1)) / CASE WHEN (($f1 = 1)) THEN (null) ELSE (($f1 - 1)) END), 0.5) (type: double), (($f6 - (($f7 * $f7) / $f1)) / $f1) (type: double), (($f6 - (($f7 * $f7) / $f1)) / CASE WHEN (($f1 = 1)) THEN (null) ELSE (($f1 - 1)) END) (type: double), $f2 (type: double), UDFToDouble($f3) (type: double)
             outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-            Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.TextInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
@@ -77,19 +78,19 @@ STAGE PLANS:
             Select Operator
               expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double), _col9 (type: double), _col10 (type: double)
               outputColumnNames: c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11
-              Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
                 aggregations: compute_stats(c1, 'hll'), compute_stats(c2, 'hll'), compute_stats(c3, 'hll'), compute_stats(c4, 'hll'), compute_stats(c5, 'hll'), compute_stats(c6, 'hll'), compute_stats(c7, 'hll'), compute_stats(c8, 'hll'), compute_stats(c9, 'hll'), compute_stats(c10, 'hll'), compute_stats(c11, 'hll')
                 mode: complete
                 outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-                Statistics: Num rows: 1 Data size: 5280 Basic stats: COMPLETE Column stats: NONE
+                Statistics: Num rows: 1 Data size: 5256 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
                   expressions: _col0 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col1 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col2 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col3 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col4 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col5 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col6 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col7 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col8 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col9 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col10 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>)
                   outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-                  Statistics: Num rows: 1 Data size: 5280 Basic stats: COMPLETE Column stats: NONE
+                  Statistics: Num rows: 1 Data size: 5256 Basic stats: COMPLETE Column stats: NONE
                   File Output Operator
                     compressed: false
-                    Statistics: Num rows: 1 Data size: 5280 Basic stats: COMPLETE Column stats: NONE
+                    Statistics: Num rows: 1 Data size: 5256 Basic stats: COMPLETE Column stats: NONE
                     table:
                         input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                         output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
@@ -146,10 +147,10 @@ POSTHOOK: type: QUERY
 POSTHOOK: Input: default@src
 POSTHOOK: Output: default@dest1
 POSTHOOK: Lineage: dest1.c1 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c10 EXPRESSION [(src)src.null, ]
+POSTHOOK: Lineage: dest1.c10 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c11 EXPRESSION [(src)src.null, ]
 POSTHOOK: Lineage: dest1.c2 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
+POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), (src)src.null, ]
 POSTHOOK: Lineage: dest1.c4 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c5 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c6 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
@@ -164,4 +165,4 @@ POSTHOOK: query: SELECT dest1.* FROM dest1
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@dest1
 #### A masked pattern was here ####
-130091.0       260.182 256.10355987055016      98.0    0.0     142.92680950752379      143.06995106518903      20428.07287599999       20469.010897795582      79136.0 309.0
+130091.0       260.182 256.10355987055016      98.0    0.0     142.9268095075238       143.06995106518906      20428.072876000002      20469.010897795593      79136.0 309.0
index d6ff5b7..ee22ba4 100644 (file)
@@ -280,29 +280,29 @@ STAGE PLANS:
               outputColumnNames: key
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: max(key), min(key), avg(key)
+                aggregations: max(key), min(key), sum(key), count(key)
                 keys: key (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col3, _col4
+                outputColumnNames: _col0, _col1, _col3, _col4, _col5
                 Statistics: Num rows: 500 Data size: 5312 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: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: string), _col3 (type: string), _col4 (type: struct<count:bigint,sum:double,input:string>)
+                  value expressions: _col1 (type: string), _col3 (type: string), _col4 (type: double), _col5 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: max(VALUE._col0), min(VALUE._col1), avg(VALUE._col2)
+          aggregations: max(VALUE._col0), min(VALUE._col1), sum(VALUE._col2), count(VALUE._col3)
           keys: KEY._col0 (type: string)
           mode: partial2
-          outputColumnNames: _col0, _col1, _col2, _col3
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
           Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
           Group By Operator
-            aggregations: max(_col1), count(_col0), min(_col2), avg(_col3)
+            aggregations: max(_col1), count(_col0), min(_col2), sum(_col3), count(_col4)
             mode: partial2
-            outputColumnNames: _col0, _col1, _col2, _col3
-            Statistics: Num rows: 1 Data size: 1148 Basic stats: COMPLETE Column stats: NONE
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4
+            Statistics: Num rows: 1 Data size: 752 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
               table:
@@ -316,21 +316,25 @@ STAGE PLANS:
           TableScan
             Reduce Output Operator
               sort order: 
-              Statistics: Num rows: 1 Data size: 1148 Basic stats: COMPLETE Column stats: NONE
-              value expressions: _col0 (type: string), _col1 (type: bigint), _col2 (type: string), _col3 (type: struct<count:bigint,sum:double,input:string>)
+              Statistics: Num rows: 1 Data size: 752 Basic stats: COMPLETE Column stats: NONE
+              value expressions: _col0 (type: string), _col1 (type: bigint), _col2 (type: string), _col3 (type: double), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: max(VALUE._col0), count(VALUE._col1), min(VALUE._col2), avg(VALUE._col3)
+          aggregations: max(VALUE._col0), count(VALUE._col1), min(VALUE._col2), sum(VALUE._col3), count(VALUE._col4)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3
-          Statistics: Num rows: 1 Data size: 1148 Basic stats: COMPLETE Column stats: NONE
-          File Output Operator
-            compressed: false
-            Statistics: Num rows: 1 Data size: 1148 Basic stats: COMPLETE Column stats: NONE
-            table:
-                input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
+          Statistics: Num rows: 1 Data size: 752 Basic stats: COMPLETE Column stats: NONE
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: bigint), _col2 (type: string), (_col3 / _col4) (type: double)
+            outputColumnNames: _col0, _col1, _col2, _col3
+            Statistics: Num rows: 1 Data size: 752 Basic stats: COMPLETE Column stats: NONE
+            File Output Operator
+              compressed: false
+              Statistics: Num rows: 1 Data size: 752 Basic stats: COMPLETE Column stats: NONE
+              table:
+                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -564,33 +568,33 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: key (type: string)
-              outputColumnNames: key
+              expressions: key (type: string), UDFToDouble(key) (type: double), (UDFToDouble(key) * UDFToDouble(key)) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: count(), stddev(key)
-                keys: key (type: string)
+                aggregations: count(), sum(_col2), sum(_col1), count(_col0)
+                keys: _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col3
+                outputColumnNames: _col0, _col1, _col3, _col4, _col5
                 Statistics: Num rows: 500 Data size: 5312 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: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: bigint), _col3 (type: struct<count:bigint,sum:double,variance:double>)
+                  value expressions: _col1 (type: bigint), _col3 (type: double), _col4 (type: double), _col5 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: count(VALUE._col0), stddev(VALUE._col1)
+          aggregations: count(VALUE._col0), sum(VALUE._col1), sum(VALUE._col2), count(VALUE._col3)
           keys: KEY._col0 (type: string)
           mode: partial2
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
           Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
           Group By Operator
-            aggregations: count(_col1), count(_col0), stddev(_col2)
+            aggregations: count(_col1), count(_col0), sum(_col2), sum(_col3), count(_col4)
             mode: partial2
-            outputColumnNames: _col0, _col1, _col2
-            Statistics: Num rows: 1 Data size: 176 Basic stats: COMPLETE Column stats: NONE
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4
+            Statistics: Num rows: 1 Data size: 48 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
               table:
@@ -604,21 +608,21 @@ STAGE PLANS:
           TableScan
             Reduce Output Operator
               sort order: 
-              Statistics: Num rows: 1 Data size: 176 Basic stats: COMPLETE Column stats: NONE
-              value expressions: _col0 (type: bigint), _col1 (type: bigint), _col2 (type: struct<count:bigint,sum:double,variance:double>)
+              Statistics: Num rows: 1 Data size: 48 Basic stats: COMPLETE Column stats: NONE
+              value expressions: _col0 (type: bigint), _col1 (type: bigint), _col2 (type: double), _col3 (type: double), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: count(VALUE._col0), count(VALUE._col1), stddev(VALUE._col2)
+          aggregations: count(VALUE._col0), count(VALUE._col1), sum(VALUE._col2), sum(VALUE._col3), count(VALUE._col4)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
-          Statistics: Num rows: 1 Data size: 176 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
+          Statistics: Num rows: 1 Data size: 48 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: bigint), _col1 (type: bigint), UDFToInteger(_col2) (type: int)
+            expressions: _col0 (type: bigint), _col1 (type: bigint), UDFToInteger(power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: int)
             outputColumnNames: _col0, _col1, _col2
-            Statistics: Num rows: 1 Data size: 176 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 48 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 176 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 48 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
@@ -683,33 +687,33 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: sum(_col0), avg(_col0), max(_col0), min(_col0), std(_col0), stddev_samp(_col0), variance(_col0), var_samp(_col0)
+                aggregations: sum(_col0), count(_col0), max(_col0), min(_col0), sum(_col2), sum(_col1)
                 keys: _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col4, _col5, _col6, _col7, _col8, _col9
+                outputColumnNames: _col0, _col1, _col2, _col4, _col5, _col6, _col7
                 Statistics: Num rows: 500 Data size: 5312 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: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: string), _col5 (type: string), _col6 (type: struct<count:bigint,sum:double,variance:double>), _col7 (type: struct<count:bigint,sum:double,variance:double>), _col8 (type: struct<count:bigint,sum:double,variance:double>), _col9 (type: struct<count:bigint,sum:double,variance:double>)
+                  value expressions: _col1 (type: double), _col2 (type: bigint), _col4 (type: string), _col5 (type: string), _col6 (type: double), _col7 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), max(VALUE._col2), min(VALUE._col3), std(VALUE._col4), stddev_samp(VALUE._col5), variance(VALUE._col6), var_samp(VALUE._col7)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), max(VALUE._col2), min(VALUE._col3), sum(VALUE._col4), sum(VALUE._col5)
           keys: KEY._col0 (type: string)
           mode: partial2
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
           Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
           Group By Operator
-            aggregations: sum(_col1), avg(_col2), count(_col0), max(_col3), min(_col4), std(_col5), stddev_samp(_col6), variance(_col7), var_samp(_col8)
+            aggregations: sum(_col1), count(_col2), count(_col0), max(_col3), min(_col4), sum(_col5), sum(_col6)
             mode: partial2
-            outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-            Statistics: Num rows: 1 Data size: 1392 Basic stats: COMPLETE Column stats: NONE
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+            Statistics: Num rows: 1 Data size: 592 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
               table:
@@ -723,21 +727,21 @@ STAGE PLANS:
           TableScan
             Reduce Output Operator
               sort order: 
-              Statistics: Num rows: 1 Data size: 1392 Basic stats: COMPLETE Column stats: NONE
-              value expressions: _col0 (type: double), _col1 (type: struct<count:bigint,sum:double,input:string>), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), _col5 (type: struct<count:bigint,sum:double,variance:double>), _col6 (type: struct<count:bigint,sum:double,variance:double>), _col7 (type: struct<count:bigint,sum:double,variance:double>), _col8 (type: struct<count:bigint,sum:double,variance:double>)
+              Statistics: Num rows: 1 Data size: 592 Basic stats: COMPLETE Column stats: NONE
+              value expressions: _col0 (type: double), _col1 (type: bigint), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), _col5 (type: double), _col6 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), count(VALUE._col2), max(VALUE._col3), min(VALUE._col4), std(VALUE._col5), stddev_samp(VALUE._col6), variance(VALUE._col7), var_samp(VALUE._col8)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), count(VALUE._col2), max(VALUE._col3), min(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-          Statistics: Num rows: 1 Data size: 1392 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+          Statistics: Num rows: 1 Data size: 592 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: double), _col1 (type: double), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), UDFToInteger(_col5) (type: int), UDFToInteger(_col6) (type: int), UDFToInteger(_col7) (type: int), UDFToInteger(_col8) (type: int)
+            expressions: _col0 (type: double), (_col0 / _col1) (type: double), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), UDFToInteger(power(((_col5 - ((_col6 * _col6) / _col1)) / _col1), 0.5)) (type: int), UDFToInteger(power(((_col5 - ((_col6 * _col6) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END), 0.5)) (type: int), UDFToInteger(((_col5 - ((_col6 * _col6) / _col1)) / _col1)) (type: int), UDFToInteger(((_col5 - ((_col6 * _col6) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END)) (type: int)
             outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-            Statistics: Num rows: 1 Data size: 1392 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 592 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 1392 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 592 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
@@ -796,26 +800,26 @@ STAGE PLANS:
               outputColumnNames: key, value
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: max(key), count(DISTINCT key), min(key), avg(key)
+                aggregations: max(key), count(DISTINCT key), min(key), sum(key), count(key)
                 keys: value (type: string), key (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
                   sort order: ++
                   Map-reduce partition columns: _col0 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col2 (type: string), _col4 (type: string), _col5 (type: struct<count:bigint,sum:double,input:string>)
+                  value expressions: _col2 (type: string), _col4 (type: string), _col5 (type: double), _col6 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: max(VALUE._col0), count(DISTINCT KEY._col1:0._col0), min(VALUE._col2), avg(VALUE._col3)
+          aggregations: max(VALUE._col0), count(DISTINCT KEY._col1:0._col0), min(VALUE._col2), sum(VALUE._col3), count(VALUE._col4)
           keys: KEY._col0 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col1 (type: string), _col2 (type: bigint), _col3 (type: string), _col4 (type: double)
+            expressions: _col1 (type: string), _col2 (type: bigint), _col3 (type: string), (_col4 / _col5) (type: double)
             outputColumnNames: _col0, _col1, _col2, _col3
             Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
index 3f28106..2ac3190 100644 (file)
@@ -542,27 +542,31 @@ STAGE PLANS:
               outputColumnNames: dec
               Statistics: Num rows: 1 Data size: 26610 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(dec), sum(dec)
+                aggregations: sum(dec), count(dec)
                 mode: hash
                 outputColumnNames: _col0, _col1
-                Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
+                Statistics: Num rows: 1 Data size: 120 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   sort order: 
-                  Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col0 (type: struct<count:bigint,sum:decimal(30,10),input:decimal(20,10)>), _col1 (type: decimal(30,10))
+                  Statistics: Num rows: 1 Data size: 120 Basic stats: COMPLETE Column stats: NONE
+                  value expressions: _col0 (type: decimal(30,10)), _col1 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0), sum(VALUE._col1)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           mode: mergepartial
           outputColumnNames: _col0, _col1
-          Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
-          File Output Operator
-            compressed: false
-            Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
-            table:
-                input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+          Statistics: Num rows: 1 Data size: 120 Basic stats: COMPLETE Column stats: NONE
+          Select Operator
+            expressions: (_col0 / _col1) (type: decimal(38,18)), CAST( _col0 AS decimal(30,10)) (type: decimal(30,10))
+            outputColumnNames: _col0, _col1
+            Statistics: Num rows: 1 Data size: 120 Basic stats: COMPLETE Column stats: NONE
+            File Output Operator
+              compressed: false
+              Statistics: Num rows: 1 Data size: 120 Basic stats: COMPLETE Column stats: NONE
+              table:
+                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -578,7 +582,7 @@ POSTHOOK: query: SELECT avg(`dec`), sum(`dec`) FROM DECIMAL_PRECISION
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@decimal_precision
 #### A masked pattern was here ####
-88499534.57586576220645        2743485571.8518386284
+88499534.575865762206451613    2743485571.8518386284
 PREHOOK: query: SELECT `dec` * cast('12345678901234567890.12345678' as decimal(38,18)) FROM DECIMAL_PRECISION LIMIT 1
 PREHOOK: type: QUERY
 PREHOOK: Input: default@decimal_precision
index e451a18..e6df9fb 100644 (file)
@@ -1282,26 +1282,26 @@ STAGE PLANS:
               outputColumnNames: key, value
               Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: sum(key), count(key), avg(key)
+                aggregations: sum(key), count(key)
                 keys: value (type: int)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3
+                outputColumnNames: _col0, _col1, _col2
                 Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: int)
                   sort order: +
                   Map-reduce partition columns: _col0 (type: int)
                   Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: decimal(30,10)), _col2 (type: bigint), _col3 (type: struct<count:bigint,sum:decimal(30,10),input:decimal(20,10)>)
+                  value expressions: _col1 (type: decimal(30,10)), _col2 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), count(VALUE._col1), avg(VALUE._col2)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: int)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3
+          outputColumnNames: _col0, _col1, _col2
           Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: int), (_col1 / CAST( _col2 AS decimal(19,0))) (type: decimal(38,18)), _col3 (type: decimal(24,14)), _col1 (type: decimal(30,10))
+            expressions: _col0 (type: int), (_col1 / CAST( _col2 AS decimal(19,0))) (type: decimal(38,18)), (CAST( _col1 AS decimal(24,14)) / _col2) (type: decimal(38,28)), _col1 (type: decimal(30,10))
             outputColumnNames: _col0, _col1, _col2, _col3
             Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
@@ -1319,10 +1319,10 @@ STAGE PLANS:
               key expressions: _col0 (type: int)
               sort order: +
               Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-              value expressions: _col1 (type: decimal(38,18)), _col2 (type: decimal(24,14)), _col3 (type: decimal(30,10))
+              value expressions: _col1 (type: decimal(38,18)), _col2 (type: decimal(38,28)), _col3 (type: decimal(30,10))
       Reduce Operator Tree:
         Select Operator
-          expressions: KEY.reducesinkkey0 (type: int), VALUE._col0 (type: decimal(38,18)), VALUE._col1 (type: decimal(24,14)), VALUE._col2 (type: decimal(30,10))
+          expressions: KEY.reducesinkkey0 (type: int), VALUE._col0 (type: decimal(38,18)), VALUE._col1 (type: decimal(38,28)), VALUE._col2 (type: decimal(30,10))
           outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
           File Output Operator
@@ -1347,23 +1347,23 @@ POSTHOOK: query: SELECT value, sum(key) / count(key), avg(key), sum(key) FROM DE
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@decimal_udf
 #### A masked pattern was here ####
--1234567890    -1234567890.123456789000000000  -1234567890.12345678900000      -1234567890.1234567890
--1255  -1255.490000000000000000        -1255.49000000000000    -1255.4900000000
--11    -1.122000000000000000   -1.12200000000000       -1.1220000000
--1     -1.120000000000000000   -1.12000000000000       -2.2400000000
-0      0.025384615384615385    0.02538461538462        0.3300000000
-1      1.048400000000000000    1.04840000000000        5.2420000000
-2      2.000000000000000000    2.00000000000000        4.0000000000
-3      3.140000000000000000    3.14000000000000        9.4200000000
-4      3.140000000000000000    3.14000000000000        3.1400000000
-10     10.000000000000000000   10.00000000000000       10.0000000000
-20     20.000000000000000000   20.00000000000000       20.0000000000
-100    100.000000000000000000  100.00000000000000      100.0000000000
-124    124.000000000000000000  124.00000000000000      124.0000000000
-125    125.200000000000000000  125.20000000000000      125.2000000000
-200    200.000000000000000000  200.00000000000000      200.0000000000
-4400   -4400.000000000000000000        -4400.00000000000000    -4400.0000000000
-1234567890     1234567890.123456780000000000   1234567890.12345678000000       1234567890.1234567800
+-1234567890    -1234567890.123456789000000000  -1234567890.1234567890000000000000000000        -1234567890.1234567890
+-1255  -1255.490000000000000000        -1255.4900000000000000000000000000      -1255.4900000000
+-11    -1.122000000000000000   -1.1220000000000000000000000000 -1.1220000000
+-1     -1.120000000000000000   -1.1200000000000000000000000000 -2.2400000000
+0      0.025384615384615385    0.0253846153846153846153846154  0.3300000000
+1      1.048400000000000000    1.0484000000000000000000000000  5.2420000000
+2      2.000000000000000000    2.0000000000000000000000000000  4.0000000000
+3      3.140000000000000000    3.1400000000000000000000000000  9.4200000000
+4      3.140000000000000000    3.1400000000000000000000000000  3.1400000000
+10     10.000000000000000000   10.0000000000000000000000000000 10.0000000000
+20     20.000000000000000000   20.0000000000000000000000000000 20.0000000000
+100    100.000000000000000000  100.0000000000000000000000000000        100.0000000000
+124    124.000000000000000000  124.0000000000000000000000000000        124.0000000000
+125    125.200000000000000000  125.2000000000000000000000000000        125.2000000000
+200    200.000000000000000000  200.0000000000000000000000000000        200.0000000000
+4400   -4400.000000000000000000        -4400.0000000000000000000000000000      -4400.0000000000
+1234567890     1234567890.123456780000000000   1234567890.1234567800000000000000000000 1234567890.1234567800
 PREHOOK: query: EXPLAIN SELECT -key FROM DECIMAL_UDF
 PREHOOK: type: QUERY
 POSTHOOK: query: EXPLAIN SELECT -key FROM DECIMAL_UDF
@@ -1849,35 +1849,39 @@ STAGE PLANS:
             alias: decimal_udf
             Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: key (type: decimal(20,10)), value (type: int)
-              outputColumnNames: key, value
+              expressions: value (type: int), key (type: decimal(20,10)), UDFToDouble(key) (type: double), (UDFToDouble(key) * UDFToDouble(key)) (type: double)
+              outputColumnNames: _col0, _col1, _col2, _col3
               Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: stddev(key), variance(key)
-                keys: value (type: int)
+                aggregations: sum(_col3), sum(_col2), count(_col1)
+                keys: _col0 (type: int)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: int)
                   sort order: +
                   Map-reduce partition columns: _col0 (type: int)
                   Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: struct<count:bigint,sum:double,variance:double>), _col2 (type: struct<count:bigint,sum:double,variance:double>)
+                  value expressions: _col1 (type: double), _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: stddev(VALUE._col0), variance(VALUE._col1)
+          aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2)
           keys: KEY._col0 (type: int)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-          File Output Operator
-            compressed: false
+          Select Operator
+            expressions: _col0 (type: int), power(((_col1 - ((_col2 * _col2) / _col3)) / _col3), 0.5) (type: double), ((_col1 - ((_col2 * _col2) / _col3)) / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
             Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-            table:
-                input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+            File Output Operator
+              compressed: false
+              Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
+              table:
+                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -1897,8 +1901,8 @@ POSTHOOK: Input: default@decimal_udf
 -1255  0.0     0.0
 -11    0.0     0.0
 -1     0.0     0.0
-0      0.22561046704494161     0.050900082840236685
-1      0.05928102563215321     0.0035142400000000066
+0      0.22561046704494161     0.05090008284023669
+1      0.05928102563215448     0.003514240000000157
 2      0.0     0.0
 3      0.0     0.0
 4      0.0     0.0
@@ -1926,35 +1930,39 @@ STAGE PLANS:
             alias: decimal_udf
             Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: key (type: decimal(20,10)), value (type: int)
-              outputColumnNames: key, value
+              expressions: value (type: int), key (type: decimal(20,10)), UDFToDouble(key) (type: double), (UDFToDouble(key) * UDFToDouble(key)) (type: double)
+              outputColumnNames: _col0, _col1, _col2, _col3
               Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: stddev_samp(key), var_samp(key)
-                keys: value (type: int)
+                aggregations: sum(_col3), sum(_col2), count(_col1)
+                keys: _col0 (type: int)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: int)
                   sort order: +
                   Map-reduce partition columns: _col0 (type: int)
                   Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: struct<count:bigint,sum:double,variance:double>), _col2 (type: struct<count:bigint,sum:double,variance:double>)
+                  value expressions: _col1 (type: double), _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: stddev_samp(VALUE._col0), var_samp(VALUE._col1)
+          aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2)
           keys: KEY._col0 (type: int)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-          File Output Operator
-            compressed: false
+          Select Operator
+            expressions: _col0 (type: int), power(((_col1 - ((_col2 * _col2) / _col3)) / CASE WHEN ((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END), 0.5) (type: double), ((_col1 - ((_col2 * _col2) / _col3)) / CASE WHEN ((_col3 = 1L)) THEN (null) ELSE ((_col3 - 1)) END) (type: double)
+            outputColumnNames: _col0, _col1, _col2
             Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
-            table:
-                input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+            File Output Operator
+              compressed: false
+              Statistics: Num rows: 1 Data size: 3590 Basic stats: COMPLETE Column stats: NONE
+              table:
+                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -1974,8 +1982,8 @@ POSTHOOK: Input: default@decimal_udf
 -1255  NULL    NULL
 -11    NULL    NULL
 -1     0.0     0.0
-0      0.2348228191855647      0.055141756410256405
-1      0.06627820154470102     0.004392800000000008
+0      0.23482281918556472     0.05514175641025642
+1      0.06627820154470243     0.0043928000000001965
 2      0.0     0.0
 3      0.0     0.0
 4      NULL    NULL
index f20320f..801c6de 100644 (file)
@@ -16,14 +16,14 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: key (type: string)
-              outputColumnNames: key
+              expressions: key (type: string), UDFToDouble(key) (type: double), (UDFToDouble(key) * UDFToDouble(key)) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: count(key), sum(key), avg(key), min(key), max(key), std(key), variance(key)
+                aggregations: count(_col0), sum(_col0), min(_col0), max(_col0), sum(_col2), sum(_col1)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
-                Statistics: Num rows: 1 Data size: 800 Basic stats: COMPLETE Column stats: NONE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
                 File Output Operator
                   compressed: false
                   table:
@@ -36,11 +36,15 @@ STAGE PLANS:
       limit: -1
       Processor Tree:
         Group By Operator
-          aggregations: count(_col0), sum(_col1), avg(_col2), min(_col3), max(_col4), std(_col5), variance(_col6)
+          aggregations: count(_col0), sum(_col1), min(_col2), max(_col3), sum(_col4), sum(_col5)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
-          Statistics: Num rows: 1 Data size: 800 Basic stats: COMPLETE Column stats: NONE
-          ListSink
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+          Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
+          Select Operator
+            expressions: _col0 (type: bigint), _col1 (type: double), (_col1 / _col0) (type: double), _col2 (type: string), _col3 (type: string), power(((_col4 - ((_col5 * _col5) / _col0)) / _col0), 0.5) (type: double), ((_col4 - ((_col5 * _col5) / _col0)) / _col0) (type: double)
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+            Statistics: Num rows: 1 Data size: 400 Basic stats: COMPLETE Column stats: NONE
+            ListSink
 
 PREHOOK: query: select count(key),sum(key),avg(key),min(key),max(key),std(key),variance(key) from src
 PREHOOK: type: QUERY
@@ -50,4 +54,4 @@ POSTHOOK: query: select count(key),sum(key),avg(key),min(key),max(key),std(key),
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@src
 #### A masked pattern was here ####
-500    130091.0        260.182 0       98      142.92680950752384      20428.072876000006
+500    130091.0        260.182 0       98      142.9268095075238       20428.072876000002
index 7c97174..0a566c7 100644 (file)
@@ -47,13 +47,13 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: value (type: string)
+              outputColumnNames: value
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Reduce Output Operator
-                key expressions: _col0 (type: string)
+                key expressions: substr(value, 5) (type: string)
                 sort order: +
-                Map-reduce partition columns: _col0 (type: string)
+                Map-reduce partition columns: substr(value, 5) (type: string)
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
       Reduce Operator Tree:
         Group By Operator
index edad22b..06c476b 100644 (file)
@@ -45,33 +45,33 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: sum(_col0), avg(_col0), avg(DISTINCT _col0), max(_col0), min(_col0), std(_col0), stddev_samp(_col0), variance(_col0), var_samp(_col0)
+                aggregations: sum(_col0), count(_col0), sum(DISTINCT _col0), count(DISTINCT _col0), max(_col0), min(_col0), sum(_col2), sum(_col1)
                 keys: _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string)
                   sort order: +
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: string), _col5 (type: string), _col6 (type: struct<count:bigint,sum:double,variance:double>), _col7 (type: struct<count:bigint,sum:double,variance:double>), _col8 (type: struct<count:bigint,sum:double,variance:double>), _col9 (type: struct<count:bigint,sum:double,variance:double>)
+                  value expressions: _col1 (type: double), _col2 (type: bigint), _col5 (type: string), _col6 (type: string), _col7 (type: double), _col8 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), avg(DISTINCT KEY._col0:0._col0), max(VALUE._col3), min(VALUE._col4), std(VALUE._col5), stddev_samp(VALUE._col6), variance(VALUE._col7), var_samp(VALUE._col8)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), sum(DISTINCT KEY._col0:0._col0), count(DISTINCT KEY._col0:1._col0), max(VALUE._col4), min(VALUE._col5), sum(VALUE._col6), sum(VALUE._col7)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-          Statistics: Num rows: 1 Data size: 1216 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7
+          Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), UDFToDouble(_col3) (type: double), UDFToDouble(_col4) (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double)
+            expressions: _col0 (type: double), (_col0 / _col1) (type: double), (_col2 / _col3) (type: double), UDFToDouble(_col4) (type: double), UDFToDouble(_col5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / _col1), 0.5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END), 0.5) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / _col1) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END) (type: double)
             outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-            Statistics: Num rows: 1 Data size: 1216 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 1216 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.TextInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
@@ -80,19 +80,19 @@ STAGE PLANS:
             Select Operator
               expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double)
               outputColumnNames: c1, c2, c3, c4, c5, c6, c7, c8, c9
-              Statistics: Num rows: 1 Data size: 1216 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
                 aggregations: compute_stats(c1, 'hll'), compute_stats(c2, 'hll'), compute_stats(c3, 'hll'), compute_stats(c4, 'hll'), compute_stats(c5, 'hll'), compute_stats(c6, 'hll'), compute_stats(c7, 'hll'), compute_stats(c8, 'hll'), compute_stats(c9, 'hll')
                 mode: complete
                 outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-                Statistics: Num rows: 1 Data size: 4064 Basic stats: COMPLETE Column stats: NONE
+                Statistics: Num rows: 1 Data size: 3984 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
                   expressions: _col0 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col1 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col2 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col3 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col4 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col5 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col6 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col7 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col8 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>)
                   outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-                  Statistics: Num rows: 1 Data size: 4064 Basic stats: COMPLETE Column stats: NONE
+                  Statistics: Num rows: 1 Data size: 3984 Basic stats: COMPLETE Column stats: NONE
                   File Output Operator
                     compressed: false
-                    Statistics: Num rows: 1 Data size: 4064 Basic stats: COMPLETE Column stats: NONE
+                    Statistics: Num rows: 1 Data size: 3984 Basic stats: COMPLETE Column stats: NONE
                     table:
                         input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                         output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
@@ -146,7 +146,7 @@ POSTHOOK: Input: default@src
 POSTHOOK: Output: default@dest1
 POSTHOOK: Lineage: dest1.c1 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c2 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
+POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), (src)src.null, ]
 POSTHOOK: Lineage: dest1.c4 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c5 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c6 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
index 2034464..f94ef49 100644 (file)
@@ -49,33 +49,33 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: sum(_col0), avg(_col0), avg(DISTINCT _col0), max(_col0), min(_col0), std(_col0), stddev_samp(_col0), variance(_col0), var_samp(_col0), sum(DISTINCT _col0), count(DISTINCT _col0)
+                aggregations: sum(_col0), count(_col0), sum(DISTINCT _col0), count(DISTINCT _col0), max(_col0), min(_col0), sum(_col2), sum(_col1)
                 keys: _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10, _col11
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string)
                   sort order: +
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: string), _col5 (type: string), _col6 (type: struct<count:bigint,sum:double,variance:double>), _col7 (type: struct<count:bigint,sum:double,variance:double>), _col8 (type: struct<count:bigint,sum:double,variance:double>), _col9 (type: struct<count:bigint,sum:double,variance:double>)
+                  value expressions: _col1 (type: double), _col2 (type: bigint), _col5 (type: string), _col6 (type: string), _col7 (type: double), _col8 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), avg(DISTINCT KEY._col0:0._col0), max(VALUE._col3), min(VALUE._col4), std(VALUE._col5), stddev_samp(VALUE._col6), variance(VALUE._col7), var_samp(VALUE._col8), sum(DISTINCT KEY._col0:1._col0), count(DISTINCT KEY._col0:2._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), sum(DISTINCT KEY._col0:0._col0), count(DISTINCT KEY._col0:1._col0), max(VALUE._col4), min(VALUE._col5), sum(VALUE._col6), sum(VALUE._col7)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-          Statistics: Num rows: 1 Data size: 1232 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7
+          Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), UDFToDouble(_col3) (type: double), UDFToDouble(_col4) (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double), _col9 (type: double), UDFToDouble(_col10) (type: double)
+            expressions: _col0 (type: double), (_col0 / _col1) (type: double), (_col2 / _col3) (type: double), UDFToDouble(_col4) (type: double), UDFToDouble(_col5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / _col1), 0.5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END), 0.5) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / _col1) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END) (type: double), _col2 (type: double), UDFToDouble(_col3) (type: double)
             outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-            Statistics: Num rows: 1 Data size: 1232 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 1232 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.TextInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
@@ -84,19 +84,19 @@ STAGE PLANS:
             Select Operator
               expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double), _col9 (type: double), _col10 (type: double)
               outputColumnNames: c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11
-              Statistics: Num rows: 1 Data size: 1232 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 516 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
                 aggregations: compute_stats(c1, 'hll'), compute_stats(c2, 'hll'), compute_stats(c3, 'hll'), compute_stats(c4, 'hll'), compute_stats(c5, 'hll'), compute_stats(c6, 'hll'), compute_stats(c7, 'hll'), compute_stats(c8, 'hll'), compute_stats(c9, 'hll'), compute_stats(c10, 'hll'), compute_stats(c11, 'hll')
                 mode: complete
                 outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-                Statistics: Num rows: 1 Data size: 4840 Basic stats: COMPLETE Column stats: NONE
+                Statistics: Num rows: 1 Data size: 4832 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
                   expressions: _col0 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col1 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col2 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col3 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col4 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col5 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col6 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col7 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col8 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col9 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>), _col10 (type: struct<columntype:string,min:double,max:double,countnulls:bigint,numdistinctvalues:bigint,ndvbitvector:binary>)
                   outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-                  Statistics: Num rows: 1 Data size: 4840 Basic stats: COMPLETE Column stats: NONE
+                  Statistics: Num rows: 1 Data size: 4832 Basic stats: COMPLETE Column stats: NONE
                   File Output Operator
                     compressed: false
-                    Statistics: Num rows: 1 Data size: 4840 Basic stats: COMPLETE Column stats: NONE
+                    Statistics: Num rows: 1 Data size: 4832 Basic stats: COMPLETE Column stats: NONE
                     table:
                         input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                         output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
@@ -153,10 +153,10 @@ POSTHOOK: type: QUERY
 POSTHOOK: Input: default@src
 POSTHOOK: Output: default@dest1
 POSTHOOK: Lineage: dest1.c1 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c10 EXPRESSION [(src)src.null, ]
+POSTHOOK: Lineage: dest1.c10 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c11 EXPRESSION [(src)src.null, ]
 POSTHOOK: Lineage: dest1.c2 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
+POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), (src)src.null, ]
 POSTHOOK: Lineage: dest1.c4 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c5 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c6 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
@@ -171,4 +171,4 @@ POSTHOOK: query: SELECT dest1.* FROM dest1
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@dest1
 #### A masked pattern was here ####
-130091.0       260.182 256.10355987055016      98.0    0.0     142.9268095075238       143.06995106518906      20428.072876    20469.01089779559       79136.0 309.0
+130091.0       260.182 256.10355987055016      98.0    0.0     142.9268095075238       143.06995106518906      20428.072876000002      20469.010897795593      79136.0 309.0
index e53e62c..1ef5a45 100644 (file)
@@ -46,12 +46,12 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: value (type: string)
+              outputColumnNames: value
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: sum(_col0), avg(_col0), avg(DISTINCT _col0), max(_col0), min(_col0), std(_col0), stddev_samp(_col0), variance(_col0), var_samp(_col0)
-                keys: _col0 (type: string)
+                aggregations: sum(substr(value, 5)), avg(substr(value, 5)), avg(DISTINCT substr(value, 5)), max(substr(value, 5)), min(substr(value, 5)), std(substr(value, 5)), stddev_samp(substr(value, 5)), variance(substr(value, 5)), var_samp(substr(value, 5))
+                keys: substr(value, 5) (type: string)
                 mode: hash
                 outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
index 1aa4cb6..83e1070 100644 (file)
@@ -45,26 +45,27 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Reduce Output Operator
                 key expressions: _col0 (type: string)
                 sort order: +
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
+                value expressions: _col2 (type: double), _col1 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(KEY._col0:0._col0), avg(KEY._col0:0._col0), avg(DISTINCT KEY._col0:0._col0), max(KEY._col0:0._col0), min(KEY._col0:0._col0), std(KEY._col0:0._col0), stddev_samp(KEY._col0:0._col0), variance(KEY._col0:0._col0), var_samp(KEY._col0:0._col0)
+          aggregations: sum(KEY._col0:0._col0), count(KEY._col0:0._col0), sum(DISTINCT KEY._col0:0._col0), count(DISTINCT KEY._col0:1._col0), max(KEY._col0:0._col0), min(KEY._col0:0._col0), sum(VALUE._col0), sum(VALUE._col1)
           mode: complete
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-          Statistics: Num rows: 1 Data size: 424 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7
+          Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), UDFToDouble(_col3) (type: double), UDFToDouble(_col4) (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double)
+            expressions: _col0 (type: double), (_col0 / _col1) (type: double), (_col2 / _col3) (type: double), UDFToDouble(_col4) (type: double), UDFToDouble(_col5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / _col1), 0.5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END), 0.5) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / _col1) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END) (type: double)
             outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-            Statistics: Num rows: 1 Data size: 424 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 424 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.TextInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
@@ -73,7 +74,7 @@ STAGE PLANS:
             Select Operator
               expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double)
               outputColumnNames: c1, c2, c3, c4, c5, c6, c7, c8, c9
-              Statistics: Num rows: 1 Data size: 424 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
                 aggregations: compute_stats(c1, 'hll'), compute_stats(c2, 'hll'), compute_stats(c3, 'hll'), compute_stats(c4, 'hll'), compute_stats(c5, 'hll'), compute_stats(c6, 'hll'), compute_stats(c7, 'hll'), compute_stats(c8, 'hll'), compute_stats(c9, 'hll')
                 mode: complete
@@ -135,7 +136,7 @@ POSTHOOK: Input: default@src
 POSTHOOK: Output: default@dest1
 POSTHOOK: Lineage: dest1.c1 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c2 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
+POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), (src)src.null, ]
 POSTHOOK: Lineage: dest1.c4 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c5 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c6 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
@@ -150,4 +151,4 @@ POSTHOOK: query: SELECT dest1.* FROM dest1
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@dest1
 #### A masked pattern was here ####
-130091.0       260.182 256.10355987055016      98.0    0.0     142.92680950752379      143.06995106518903      20428.07287599999       20469.010897795582
+130091.0       260.182 256.10355987055016      98.0    0.0     142.9268095075238       143.06995106518906      20428.072876000002      20469.010897795593
index bb964e6..6acc9a9 100644 (file)
@@ -49,26 +49,27 @@ STAGE PLANS:
             alias: src
             Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
             Select Operator
-              expressions: substr(value, 5) (type: string)
-              outputColumnNames: _col0
+              expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+              outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Reduce Output Operator
                 key expressions: _col0 (type: string)
                 sort order: +
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
+                value expressions: _col2 (type: double), _col1 (type: double)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(KEY._col0:0._col0), avg(KEY._col0:0._col0), avg(DISTINCT KEY._col0:0._col0), max(KEY._col0:0._col0), min(KEY._col0:0._col0), std(KEY._col0:0._col0), stddev_samp(KEY._col0:0._col0), variance(KEY._col0:0._col0), var_samp(KEY._col0:0._col0), sum(DISTINCT KEY._col0:1._col0), count(DISTINCT KEY._col0:2._col0)
+          aggregations: sum(KEY._col0:0._col0), count(KEY._col0:0._col0), sum(DISTINCT KEY._col0:0._col0), count(DISTINCT KEY._col0:1._col0), max(KEY._col0:0._col0), min(KEY._col0:0._col0), sum(VALUE._col0), sum(VALUE._col1)
           mode: complete
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-          Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7
+          Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
           Select Operator
-            expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), UDFToDouble(_col3) (type: double), UDFToDouble(_col4) (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double), _col9 (type: double), UDFToDouble(_col10) (type: double)
+            expressions: _col0 (type: double), (_col0 / _col1) (type: double), (_col2 / _col3) (type: double), UDFToDouble(_col4) (type: double), UDFToDouble(_col5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / _col1), 0.5) (type: double), power(((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END), 0.5) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / _col1) (type: double), ((_col6 - ((_col7 * _col7) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END) (type: double), _col2 (type: double), UDFToDouble(_col3) (type: double)
             outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9, _col10
-            Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+            Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
               compressed: false
-              Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
               table:
                   input format: org.apache.hadoop.mapred.TextInputFormat
                   output format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
@@ -77,7 +78,7 @@ STAGE PLANS:
             Select Operator
               expressions: _col0 (type: double), _col1 (type: double), _col2 (type: double), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: double), _col7 (type: double), _col8 (type: double), _col9 (type: double), _col10 (type: double)
               outputColumnNames: c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11
-              Statistics: Num rows: 1 Data size: 440 Basic stats: COMPLETE Column stats: NONE
+              Statistics: Num rows: 1 Data size: 416 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
                 aggregations: compute_stats(c1, 'hll'), compute_stats(c2, 'hll'), compute_stats(c3, 'hll'), compute_stats(c4, 'hll'), compute_stats(c5, 'hll'), compute_stats(c6, 'hll'), compute_stats(c7, 'hll'), compute_stats(c8, 'hll'), compute_stats(c9, 'hll'), compute_stats(c10, 'hll'), compute_stats(c11, 'hll')
                 mode: complete
@@ -142,10 +143,10 @@ POSTHOOK: type: QUERY
 POSTHOOK: Input: default@src
 POSTHOOK: Output: default@dest1
 POSTHOOK: Lineage: dest1.c1 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c10 EXPRESSION [(src)src.null, ]
+POSTHOOK: Lineage: dest1.c10 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c11 EXPRESSION [(src)src.null, ]
 POSTHOOK: Lineage: dest1.c2 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
-POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
+POSTHOOK: Lineage: dest1.c3 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), (src)src.null, ]
 POSTHOOK: Lineage: dest1.c4 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c5 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
 POSTHOOK: Lineage: dest1.c6 EXPRESSION [(src)src.FieldSchema(name:value, type:string, comment:default), ]
@@ -160,4 +161,4 @@ POSTHOOK: query: SELECT dest1.* FROM dest1
 POSTHOOK: type: QUERY
 POSTHOOK: Input: default@dest1
 #### A masked pattern was here ####
-130091.0       260.182 256.10355987055016      98.0    0.0     142.92680950752379      143.06995106518903      20428.07287599999       20469.010897795582      79136.0 309.0
+130091.0       260.182 256.10355987055016      98.0    0.0     142.9268095075238       143.06995106518906      20428.072876000002      20469.010897795593      79136.0 309.0
index e894205..5d27f4c 100644 (file)
@@ -45,27 +45,27 @@ STAGE PLANS:
               outputColumnNames: a, b, c
               Statistics: Num rows: 1 Data size: 720 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(c), count()
+                aggregations: sum(c), count(c), count()
                 keys: a (type: string), b (type: string), 0L (type: bigint)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
                 Statistics: Num rows: 4 Data size: 2880 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   sort order: +++
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   Statistics: Num rows: 4 Data size: 2880 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col3 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: bigint)
+                  value expressions: _col3 (type: double), _col4 (type: bigint), _col5 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0), count(VALUE._col1)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), count(VALUE._col2)
           keys: KEY._col0 (type: string), KEY._col1 (type: string), KEY._col2 (type: bigint)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col3, _col4
+          outputColumnNames: _col0, _col1, _col3, _col4, _col5
           Statistics: Num rows: 2 Data size: 1440 Basic stats: COMPLETE Column stats: NONE
           pruneGroupingSetId: true
           Select Operator
-            expressions: _col0 (type: string), _col1 (type: string), _col3 (type: double), _col4 (type: bigint)
+            expressions: _col0 (type: string), _col1 (type: string), (_col3 / _col4) (type: double), _col5 (type: bigint)
             outputColumnNames: _col0, _col1, _col2, _col3
             Statistics: Num rows: 2 Data size: 1440 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
@@ -105,27 +105,27 @@ STAGE PLANS:
               outputColumnNames: a, b, c
               Statistics: Num rows: 1 Data size: 720 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(c), count()
+                aggregations: sum(c), count(c), count()
                 keys: a (type: string), b (type: string), 0L (type: bigint)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
                 Statistics: Num rows: 4 Data size: 2880 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   sort order: +++
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   Statistics: Num rows: 4 Data size: 2880 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col3 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: bigint)
+                  value expressions: _col3 (type: double), _col4 (type: bigint), _col5 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0), count(VALUE._col1)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), count(VALUE._col2)
           keys: KEY._col0 (type: string), KEY._col1 (type: string), KEY._col2 (type: bigint)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col3, _col4
+          outputColumnNames: _col0, _col1, _col3, _col4, _col5
           Statistics: Num rows: 2 Data size: 1440 Basic stats: COMPLETE Column stats: NONE
           pruneGroupingSetId: true
           Select Operator
-            expressions: _col0 (type: string), _col1 (type: string), _col3 (type: double), _col4 (type: bigint)
+            expressions: _col0 (type: string), _col1 (type: string), (_col3 / _col4) (type: double), _col5 (type: bigint)
             outputColumnNames: _col0, _col1, _col2, _col3
             Statistics: Num rows: 2 Data size: 1440 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
@@ -191,23 +191,23 @@ STAGE PLANS:
               outputColumnNames: a, b, c
               Statistics: Num rows: 1 Data size: 720 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(c), count()
+                aggregations: sum(c), count(c), count()
                 keys: a (type: string), b (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
                 Statistics: Num rows: 1 Data size: 720 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
                   sort order: ++
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 1 Data size: 720 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:string>), _col3 (type: bigint)
+                  value expressions: _col2 (type: double), _col3 (type: bigint), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0), count(VALUE._col1)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), count(VALUE._col2)
           keys: KEY._col0 (type: string), KEY._col1 (type: string), 0L (type: bigint)
           mode: partials
-          outputColumnNames: _col0, _col1, _col2, _col3, _col4
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
           Statistics: Num rows: 4 Data size: 2880 Basic stats: COMPLETE Column stats: NONE
           File Output Operator
             compressed: false
@@ -225,17 +225,17 @@ STAGE PLANS:
               sort order: +++
               Map-reduce partition columns: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
               Statistics: Num rows: 4 Data size: 2880 Basic stats: COMPLETE Column stats: NONE
-              value expressions: _col3 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: bigint)
+              value expressions: _col3 (type: double), _col4 (type: bigint), _col5 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0), count(VALUE._col1)
+          aggregations: sum(VALUE._col0), count(VALUE._col1), count(VALUE._col2)
           keys: KEY._col0 (type: string), KEY._col1 (type: string), KEY._col2 (type: bigint)
           mode: final
-          outputColumnNames: _col0, _col1, _col3, _col4
+          outputColumnNames: _col0, _col1, _col3, _col4, _col5
           Statistics: Num rows: 2 Data size: 1440 Basic stats: COMPLETE Column stats: NONE
           pruneGroupingSetId: true
           Select Operator
-            expressions: _col0 (type: string), _col1 (type: string), _col3 (type: double), _col4 (type: bigint)
+            expressions: _col0 (type: string), _col1 (type: string), (_col3 / _col4) (type: double), _col5 (type: bigint)
             outputColumnNames: _col0, _col1, _col2, _col3
             Statistics: Num rows: 2 Data size: 1440 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
index 12fae67..281b81d 100644 (file)
@@ -311,10 +311,10 @@ STAGE PLANS:
           outputColumnNames: _col0, _col1, _col2, _col4
           Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
           Group By Operator
-            aggregations: sum(_col2), avg(_col0), count(_col4)
+            aggregations: sum(_col2), sum(_col0), count(_col0), count(_col4)
             keys: _col1 (type: string)
             mode: hash
-            outputColumnNames: _col0, _col1, _col2, _col3
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4
             Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
             File Output Operator
               compressed: false
@@ -332,16 +332,16 @@ STAGE PLANS:
               sort order: +
               Map-reduce partition columns: _col0 (type: string)
               Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
-              value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:double>), _col3 (type: bigint)
+              value expressions: _col1 (type: double), _col2 (type: double), _col3 (type: bigint), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), count(VALUE._col2)
+          aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), count(VALUE._col3)
           keys: KEY._col0 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
           Statistics: Num rows: 275 Data size: 2921 Basic stats: PARTIAL Column stats: NONE
           Filter Operator
-            predicate: ((_col1 <= 4074689.000000041D) and (_col2 <= 822.0D) and (_col3 > 4L)) (type: boolean)
+            predicate: (((_col2 / _col3) <= 822.0D) and (_col1 <= 4074689.000000041D) and (_col4 > 4L)) (type: boolean)
             Statistics: Num rows: 10 Data size: 106 Basic stats: PARTIAL Column stats: NONE
             Select Operator
               expressions: _col0 (type: string)
@@ -430,10 +430,10 @@ STAGE PLANS:
           outputColumnNames: _col0, _col1, _col2, _col4
           Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
           Group By Operator
-            aggregations: sum(_col2), avg(_col0), count(_col4)
+            aggregations: sum(_col2), sum(_col0), count(_col0), count(_col4)
             keys: _col1 (type: string)
             mode: hash
-            outputColumnNames: _col0, _col1, _col2, _col3
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4
             Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
             File Output Operator
               compressed: false
@@ -451,20 +451,20 @@ STAGE PLANS:
               sort order: +
               Map-reduce partition columns: _col0 (type: string)
               Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
-              value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:double>), _col3 (type: bigint)
+              value expressions: _col1 (type: double), _col2 (type: double), _col3 (type: bigint), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), count(VALUE._col2)
+          aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), count(VALUE._col3)
           keys: KEY._col0 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
           Statistics: Num rows: 275 Data size: 2921 Basic stats: PARTIAL Column stats: NONE
           Select Operator
-            expressions: _col0 (type: string), _col1 (type: double), _col2 (type: double), _col3 (type: bigint)
-            outputColumnNames: _col1, _col2, _col3, _col4
+            expressions: _col0 (type: string), _col1 (type: double), _col2 (type: double), _col3 (type: bigint), _col4 (type: bigint)
+            outputColumnNames: _col1, _col2, _col3, _col4, _col5
             Statistics: Num rows: 275 Data size: 2921 Basic stats: PARTIAL Column stats: NONE
             Filter Operator
-              predicate: ((_col2 <= 4074689.000000041D) and (_col3 <= 822.0D) and (_col4 > 4L)) (type: boolean)
+              predicate: (((_col3 / _col4) <= 822.0D) and (_col2 <= 4074689.000000041D) and (_col5 > 4L)) (type: boolean)
               Statistics: Num rows: 10 Data size: 106 Basic stats: PARTIAL Column stats: NONE
               Select Operator
                 expressions: _col1 (type: string)
@@ -553,10 +553,10 @@ STAGE PLANS:
           outputColumnNames: _col0, _col1, _col2, _col4
           Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
           Group By Operator
-            aggregations: sum(_col2), avg(_col0), count(_col4)
+            aggregations: sum(_col2), sum(_col0), count(_col0), count(_col4)
             keys: _col1 (type: string)
             mode: hash
-            outputColumnNames: _col0, _col1, _col2, _col3
+            outputColumnNames: _col0, _col1, _col2, _col3, _col4
             Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
             File Output Operator
               compressed: false
@@ -574,20 +574,20 @@ STAGE PLANS:
               sort order: +
               Map-reduce partition columns: _col0 (type: string)
               Statistics: Num rows: 550 Data size: 5843 Basic stats: PARTIAL Column stats: NONE
-              value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:double>), _col3 (type: bigint)
+              value expressions: _col1 (type: double), _col2 (type: double), _col3 (type: bigint), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: sum(VALUE._col0), avg(VALUE._col1), count(VALUE._col2)
+          aggregations: sum(VALUE._col0), sum(VALUE._col1), count(VALUE._col2), count(VALUE._col3)
           keys: KEY._col0 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2, _col3
+          outputColumnNames: _col0, _col1, _col2, _col3, _col4
           Statistics: Num rows: 275 Data size: 2921 Basic stats: PARTIAL Column stats: NONE
           Select Operator
-            expressions: _col0 (type: string), _col1 (type: double), _col2 (type: double), _col3 (type: bigint)
-            outputColumnNames: _col1, _col2, _col3, _col4
+            expressions: _col0 (type: string), _col1 (type: double), _col2 (type: double), _col3 (type: bigint), _col4 (type: bigint)
+            outputColumnNames: _col1, _col2, _col3, _col4, _col5
             Statistics: Num rows: 275 Data size: 2921 Basic stats: PARTIAL Column stats: NONE
             Filter Operator
-              predicate: ((_col2 <= 4074689.000000041D) and (_col3 <= 822.0D) and (_col4 > 4L)) (type: boolean)
+              predicate: (((_col3 / _col4) <= 822.0D) and (_col2 <= 4074689.000000041D) and (_col5 > 4L)) (type: boolean)
               Statistics: Num rows: 10 Data size: 106 Basic stats: PARTIAL Column stats: NONE
               Select Operator
                 expressions: _col1 (type: string), _col1 (type: string)
index 5aeb521..bae6e24 100644 (file)
@@ -24,10 +24,10 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col0 (type: string), _col1 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
@@ -35,24 +35,28 @@ STAGE PLANS:
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                   TopN Hash Memory Usage: 0.3
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          Limit
-            Number of rows: 20
-            Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-            File Output Operator
-              compressed: false
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: string), (_col2 / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
+            Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
+            Limit
+              Number of rows: 20
               Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-              table:
-                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+              File Output Operator
+                compressed: false
+                Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
+                table:
+                    input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                    output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                    serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -118,10 +122,10 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col0 (type: string), _col1 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
@@ -129,24 +133,28 @@ STAGE PLANS:
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                   TopN Hash Memory Usage: 0.3
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          Limit
-            Number of rows: 20
-            Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-            File Output Operator
-              compressed: false
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: string), (_col2 / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
+            Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
+            Limit
+              Number of rows: 20
               Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-              table:
-                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+              File Output Operator
+                compressed: false
+                Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
+                table:
+                    input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                    output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                    serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -212,10 +220,10 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col0 (type: string), _col1 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
@@ -223,24 +231,28 @@ STAGE PLANS:
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                   TopN Hash Memory Usage: 0.3
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          Limit
-            Number of rows: 20
-            Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-            File Output Operator
-              compressed: false
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: string), (_col2 / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
+            Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
+            Limit
+              Number of rows: 20
               Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-              table:
-                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+              File Output Operator
+                compressed: false
+                Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
+                table:
+                    input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                    output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                    serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -306,10 +318,10 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col1 (type: string), _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
@@ -317,24 +329,28 @@ STAGE PLANS:
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                   TopN Hash Memory Usage: 0.3
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          Limit
-            Number of rows: 20
-            Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-            File Output Operator
-              compressed: false
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: string), (_col2 / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
+            Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
+            Limit
+              Number of rows: 20
               Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-              table:
-                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+              File Output Operator
+                compressed: false
+                Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
+                table:
+                    input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                    output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                    serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -400,10 +416,10 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col1 (type: string), _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
@@ -411,24 +427,28 @@ STAGE PLANS:
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                   TopN Hash Memory Usage: 0.3
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          Limit
-            Number of rows: 20
-            Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-            File Output Operator
-              compressed: false
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: string), (_col2 / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
+            Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
+            Limit
+              Number of rows: 20
               Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-              table:
-                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+              File Output Operator
+                compressed: false
+                Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
+                table:
+                    input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                    output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                    serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -494,10 +514,10 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col1 (type: string), _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string)
@@ -505,24 +525,28 @@ STAGE PLANS:
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                   Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
                   TopN Hash Memory Usage: 0.3
-                  value expressions: _col2 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col2 (type: double), _col3 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col2
+          outputColumnNames: _col0, _col1, _col2, _col3
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          Limit
-            Number of rows: 20
-            Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-            File Output Operator
-              compressed: false
+          Select Operator
+            expressions: _col0 (type: string), _col1 (type: string), (_col2 / _col3) (type: double)
+            outputColumnNames: _col0, _col1, _col2
+            Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
+            Limit
+              Number of rows: 20
               Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
-              table:
-                  input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                  output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                  serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+              File Output Operator
+                compressed: false
+                Statistics: Num rows: 20 Data size: 200 Basic stats: COMPLETE Column stats: NONE
+                table:
+                    input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                    output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                    serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -821,30 +845,34 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col1)
+                aggregations: sum(_col1), count(_col1)
                 keys: _col0 (type: string)
                 mode: hash
-                outputColumnNames: _col0, _col1
+                outputColumnNames: _col0, _col1, _col2
                 Statistics: Num rows: 500 Data size: 5312 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: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col1 (type: double), _col2 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string)
           mode: mergepartial
-          outputColumnNames: _col0, _col1
+          outputColumnNames: _col0, _col1, _col2
           Statistics: Num rows: 250 Data size: 2656 Basic stats: COMPLETE Column stats: NONE
-          File Output Operator
-            compressed: false
-            table:
-                input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                serde: org.apache.hadoop.hive.serde2.lazybinary.LazyBinarySerDe
+          Select Operator
+            expressions: _col0 (type: string), (_col1 / _col2) (type: double)
+            outputColumnNames: _col0, _col1
+            Statistics: Num rows: 250 Data size: 2656 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
@@ -936,27 +964,27 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col0 (type: string), _col1 (type: string), 0L (type: bigint)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
                 Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   sort order: +++
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col3 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col3 (type: double), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string), KEY._col2 (type: bigint)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col3
+          outputColumnNames: _col0, _col1, _col3, _col4
           Statistics: Num rows: 750 Data size: 7968 Basic stats: COMPLETE Column stats: NONE
           pruneGroupingSetId: true
           Select Operator
-            expressions: _col1 (type: string), _col0 (type: string), _col3 (type: double)
+            expressions: _col1 (type: string), _col0 (type: string), (_col3 / _col4) (type: double)
             outputColumnNames: _col0, _col1, _col2
             Statistics: Num rows: 750 Data size: 7968 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
@@ -1025,27 +1053,27 @@ STAGE PLANS:
               outputColumnNames: _col0, _col1, _col2
               Statistics: Num rows: 500 Data size: 5312 Basic stats: COMPLETE Column stats: NONE
               Group By Operator
-                aggregations: avg(_col2)
+                aggregations: sum(_col2), count(_col2)
                 keys: _col0 (type: string), _col1 (type: string), 0L (type: bigint)
                 mode: hash
-                outputColumnNames: _col0, _col1, _col2, _col3
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
                 Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE
                 Reduce Output Operator
                   key expressions: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   sort order: +++
                   Map-reduce partition columns: _col0 (type: string), _col1 (type: string), _col2 (type: bigint)
                   Statistics: Num rows: 1500 Data size: 15936 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col3 (type: struct<count:bigint,sum:double,input:double>)
+                  value expressions: _col3 (type: double), _col4 (type: bigint)
       Reduce Operator Tree:
         Group By Operator
-          aggregations: avg(VALUE._col0)
+          aggregations: sum(VALUE._col0), count(VALUE._col1)
           keys: KEY._col0 (type: string), KEY._col1 (type: string), KEY._col2 (type: bigint)
           mode: mergepartial
-          outputColumnNames: _col0, _col1, _col3
+          outputColumnNames: _col0, _col1, _col3, _col4
           Statistics: Num rows: 750 Data size: 7968 Basic stats: COMPLETE Column stats: NONE
           pruneGroupingSetId: true
           Select Operator
-            expressions: _col1 (type: string), _col0 (type: string), _col3 (type: double)
+            expressions: _col1 (type: string), _col0 (type: string), (_col3 / _col4) (type: double)
             outputColumnNames: _col0, _col1, _col2
             Statistics: Num rows: 750 Data size: 7968 Basic stats: COMPLETE Column stats: NONE
             File Output Operator
index 347ae37..df84bbf 100644 (file)
@@ -289,52 +289,56 @@ STAGE PLANS:
                     outputColumnNames: key
                     Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: max(key), min(key), avg(key)
+                      aggregations: max(key), min(key), sum(key), count(key)
                       keys: key (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1, _col3, _col4
-                      Statistics: Num rows: 250 Data size: 177750 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col3, _col4, _col5
+                      Statistics: Num rows: 250 Data size: 117750 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 177750 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: string), _col3 (type: string), _col4 (type: struct<count:bigint,sum:double,input:string>)
+                        Statistics: Num rows: 250 Data size: 117750 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: string), _col3 (type: string), _col4 (type: double), _col5 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: max(VALUE._col0), min(VALUE._col1), avg(VALUE._col2)
+                aggregations: max(VALUE._col0), min(VALUE._col1), sum(VALUE._col2), count(VALUE._col3)
                 keys: KEY._col0 (type: string)
                 mode: partial2
-                outputColumnNames: _col0, _col1, _col2, _col3
-                Statistics: Num rows: 250 Data size: 177750 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                Statistics: Num rows: 250 Data size: 117750 Basic stats: COMPLETE Column stats: COMPLETE
                 Group By Operator
-                  aggregations: max(_col1), count(_col0), min(_col2), avg(_col3)
+                  aggregations: max(_col1), count(_col0), min(_col2), sum(_col3), count(_col4)
                   mode: partial2
-                  outputColumnNames: _col0, _col1, _col2, _col3
-                  Statistics: Num rows: 1 Data size: 632 Basic stats: COMPLETE Column stats: COMPLETE
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                  Statistics: Num rows: 1 Data size: 392 Basic stats: COMPLETE Column stats: COMPLETE
                   Reduce Output Operator
                     sort order: 
-                    Statistics: Num rows: 1 Data size: 632 Basic stats: COMPLETE Column stats: COMPLETE
-                    value expressions: _col0 (type: string), _col1 (type: bigint), _col2 (type: string), _col3 (type: struct<count:bigint,sum:double,input:string>)
+                    Statistics: Num rows: 1 Data size: 392 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: string), _col1 (type: bigint), _col2 (type: string), _col3 (type: double), _col4 (type: bigint)
         Reducer 3 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: max(VALUE._col0), count(VALUE._col1), min(VALUE._col2), avg(VALUE._col3)
+                aggregations: max(VALUE._col0), count(VALUE._col1), min(VALUE._col2), sum(VALUE._col3), count(VALUE._col4)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1, _col2, _col3
-                Statistics: Num rows: 1 Data size: 384 Basic stats: COMPLETE Column stats: COMPLETE
-                File Output Operator
-                  compressed: false
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                Statistics: Num rows: 1 Data size: 392 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: _col0 (type: string), _col1 (type: bigint), _col2 (type: string), (_col3 / _col4) (type: double)
+                  outputColumnNames: _col0, _col1, _col2, _col3
                   Statistics: Num rows: 1 Data size: 384 Basic stats: COMPLETE Column stats: COMPLETE
-                  table:
-                      input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                      output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                      serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+                  File Output Operator
+                    compressed: false
+                    Statistics: Num rows: 1 Data size: 384 Basic stats: COMPLETE Column stats: COMPLETE
+                    table:
+                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                        serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
@@ -576,51 +580,51 @@ STAGE PLANS:
                   alias: src
                   Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE
                   Select Operator
-                    expressions: key (type: string)
-                    outputColumnNames: key
+                    expressions: key (type: string), UDFToDouble(key) (type: double), (UDFToDouble(key) * UDFToDouble(key)) (type: double)
+                    outputColumnNames: _col0, _col1, _col2
                     Statistics: Num rows: 500 Data size: 43500 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: count(), stddev(key)
-                      keys: key (type: string)
+                      aggregations: count(), sum(_col2), sum(_col1), count(_col0)
+                      keys: _col0 (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1, _col3
-                      Statistics: Num rows: 250 Data size: 43750 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col3, _col4, _col5
+                      Statistics: Num rows: 250 Data size: 29750 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 43750 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: bigint), _col3 (type: struct<count:bigint,sum:double,variance:double>)
+                        Statistics: Num rows: 250 Data size: 29750 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: bigint), _col3 (type: double), _col4 (type: double), _col5 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: count(VALUE._col0), stddev(VALUE._col1)
+                aggregations: count(VALUE._col0), sum(VALUE._col1), sum(VALUE._col2), count(VALUE._col3)
                 keys: KEY._col0 (type: string)
                 mode: partial2
-                outputColumnNames: _col0, _col1, _col2
-                Statistics: Num rows: 250 Data size: 43750 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                Statistics: Num rows: 250 Data size: 29750 Basic stats: COMPLETE Column stats: COMPLETE
                 Group By Operator
-                  aggregations: count(_col1), count(_col0), stddev(_col2)
+                  aggregations: count(_col1), count(_col0), sum(_col2), sum(_col3), count(_col4)
                   mode: partial2
-                  outputColumnNames: _col0, _col1, _col2
-                  Statistics: Num rows: 1 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                  Statistics: Num rows: 1 Data size: 40 Basic stats: COMPLETE Column stats: COMPLETE
                   Reduce Output Operator
                     sort order: 
-                    Statistics: Num rows: 1 Data size: 96 Basic stats: COMPLETE Column stats: COMPLETE
-                    value expressions: _col0 (type: bigint), _col1 (type: bigint), _col2 (type: struct<count:bigint,sum:double,variance:double>)
+                    Statistics: Num rows: 1 Data size: 40 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: bigint), _col1 (type: bigint), _col2 (type: double), _col3 (type: double), _col4 (type: bigint)
         Reducer 3 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: count(VALUE._col0), count(VALUE._col1), stddev(VALUE._col2)
+                aggregations: count(VALUE._col0), count(VALUE._col1), sum(VALUE._col2), sum(VALUE._col3), count(VALUE._col4)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1, _col2
-                Statistics: Num rows: 1 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4
+                Statistics: Num rows: 1 Data size: 40 Basic stats: COMPLETE Column stats: COMPLETE
                 Select Operator
-                  expressions: _col0 (type: bigint), _col1 (type: bigint), UDFToInteger(_col2) (type: int)
+                  expressions: _col0 (type: bigint), _col1 (type: bigint), UDFToInteger(power(((_col2 - ((_col3 * _col3) / _col4)) / _col4), 0.5)) (type: int)
                   outputColumnNames: _col0, _col1, _col2
                   Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: COMPLETE
                   File Output Operator
@@ -696,51 +700,51 @@ STAGE PLANS:
                   alias: src
                   Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE
                   Select Operator
-                    expressions: substr(value, 5) (type: string)
-                    outputColumnNames: _col0
+                    expressions: substr(value, 5) (type: string), UDFToDouble(substr(value, 5)) (type: double), (UDFToDouble(substr(value, 5)) * UDFToDouble(substr(value, 5))) (type: double)
+                    outputColumnNames: _col0, _col1, _col2
                     Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: sum(_col0), avg(_col0), max(_col0), min(_col0), std(_col0), stddev_samp(_col0), variance(_col0), var_samp(_col0)
+                      aggregations: sum(_col0), count(_col0), max(_col0), min(_col0), sum(_col2), sum(_col1)
                       keys: _col0 (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1, _col2, _col4, _col5, _col6, _col7, _col8, _col9
-                      Statistics: Num rows: 250 Data size: 284000 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2, _col4, _col5, _col6, _col7
+                      Statistics: Num rows: 250 Data size: 146000 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 284000 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: double), _col2 (type: struct<count:bigint,sum:double,input:string>), _col4 (type: string), _col5 (type: string), _col6 (type: struct<count:bigint,sum:double,variance:double>), _col7 (type: struct<count:bigint,sum:double,variance:double>), _col8 (type: struct<count:bigint,sum:double,variance:double>), _col9 (type: struct<count:bigint,sum:double,variance:double>)
+                        Statistics: Num rows: 250 Data size: 146000 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: double), _col2 (type: bigint), _col4 (type: string), _col5 (type: string), _col6 (type: double), _col7 (type: double)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: sum(VALUE._col0), avg(VALUE._col1), max(VALUE._col2), min(VALUE._col3), std(VALUE._col4), stddev_samp(VALUE._col5), variance(VALUE._col6), var_samp(VALUE._col7)
+                aggregations: sum(VALUE._col0), count(VALUE._col1), max(VALUE._col2), min(VALUE._col3), sum(VALUE._col4), sum(VALUE._col5)
                 keys: KEY._col0 (type: string)
                 mode: partial2
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-                Statistics: Num rows: 250 Data size: 284000 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+                Statistics: Num rows: 250 Data size: 146000 Basic stats: COMPLETE Column stats: COMPLETE
                 Group By Operator
-                  aggregations: sum(_col1), avg(_col2), count(_col0), max(_col3), min(_col4), std(_col5), stddev_samp(_col6), variance(_col7), var_samp(_col8)
+                  aggregations: sum(_col1), count(_col2), count(_col0), max(_col3), min(_col4), sum(_col5), sum(_col6)
                   mode: partial2
-                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-                  Statistics: Num rows: 1 Data size: 960 Basic stats: COMPLETE Column stats: COMPLETE
+                  outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+                  Statistics: Num rows: 1 Data size: 408 Basic stats: COMPLETE Column stats: COMPLETE
                   Reduce Output Operator
                     sort order: 
-                    Statistics: Num rows: 1 Data size: 960 Basic stats: COMPLETE Column stats: COMPLETE
-                    value expressions: _col0 (type: double), _col1 (type: struct<count:bigint,sum:double,input:string>), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), _col5 (type: struct<count:bigint,sum:double,variance:double>), _col6 (type: struct<count:bigint,sum:double,variance:double>), _col7 (type: struct<count:bigint,sum:double,variance:double>), _col8 (type: struct<count:bigint,sum:double,variance:double>)
+                    Statistics: Num rows: 1 Data size: 408 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: double), _col1 (type: bigint), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), _col5 (type: double), _col6 (type: double)
         Reducer 3 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: sum(VALUE._col0), avg(VALUE._col1), count(VALUE._col2), max(VALUE._col3), min(VALUE._col4), std(VALUE._col5), stddev_samp(VALUE._col6), variance(VALUE._col7), var_samp(VALUE._col8)
+                aggregations: sum(VALUE._col0), count(VALUE._col1), count(VALUE._col2), max(VALUE._col3), min(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-                Statistics: Num rows: 1 Data size: 424 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+                Statistics: Num rows: 1 Data size: 408 Basic stats: COMPLETE Column stats: COMPLETE
                 Select Operator
-                  expressions: _col0 (type: double), _col1 (type: double), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), UDFToInteger(_col5) (type: int), UDFToInteger(_col6) (type: int), UDFToInteger(_col7) (type: int), UDFToInteger(_col8) (type: int)
+                  expressions: _col0 (type: double), (_col0 / _col1) (type: double), _col2 (type: bigint), _col3 (type: string), _col4 (type: string), UDFToInteger(power(((_col5 - ((_col6 * _col6) / _col1)) / _col1), 0.5)) (type: int), UDFToInteger(power(((_col5 - ((_col6 * _col6) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END), 0.5)) (type: int), UDFToInteger(((_col5 - ((_col6 * _col6) / _col1)) / _col1)) (type: int), UDFToInteger(((_col5 - ((_col6 * _col6) / _col1)) / CASE WHEN ((_col1 = 1L)) THEN (null) ELSE ((_col1 - 1)) END)) (type: int)
                   outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
                   Statistics: Num rows: 1 Data size: 408 Basic stats: COMPLETE Column stats: COMPLETE
                   File Output Operator
@@ -810,30 +814,30 @@ STAGE PLANS:
                     outputColumnNames: key, value
                     Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: max(key), count(DISTINCT key), min(key), avg(key)
+                      aggregations: max(key), count(DISTINCT key), min(key), sum(key), count(key)
                       keys: value (type: string), key (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
-                      Statistics: Num rows: 250 Data size: 202500 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
+                      Statistics: Num rows: 250 Data size: 142500 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string), _col1 (type: string)
                         sort order: ++
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 202500 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col2 (type: string), _col4 (type: string), _col5 (type: struct<count:bigint,sum:double,input:string>)
+                        Statistics: Num rows: 250 Data size: 142500 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col2 (type: string), _col4 (type: string), _col5 (type: double), _col6 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: max(VALUE._col0), count(DISTINCT KEY._col1:0._col0), min(VALUE._col2), avg(VALUE._col3)
+                aggregations: max(VALUE._col0), count(DISTINCT KEY._col1:0._col0), min(VALUE._col2), sum(VALUE._col3), count(VALUE._col4)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4
-                Statistics: Num rows: 250 Data size: 118750 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                Statistics: Num rows: 250 Data size: 120750 Basic stats: COMPLETE Column stats: COMPLETE
                 Select Operator
-                  expressions: _col1 (type: string), _col2 (type: bigint), _col3 (type: string), _col4 (type: double)
+                  expressions: _col1 (type: string), _col2 (type: bigint), _col3 (type: string), (_col4 / _col5) (type: double)
                   outputColumnNames: _col0, _col1, _col2, _col3
                   Statistics: Num rows: 250 Data size: 96000 Basic stats: COMPLETE Column stats: COMPLETE
                   File Output Operator
index 98743eb..ce53955 100644 (file)
@@ -2144,42 +2144,42 @@ Stage-0
     limit:-1
     Stage-1
       Reducer 3 llap
-      File Output Operator [FS_21]
-        Merge Join Operator [MERGEJOIN_26] (rows=6 width=227)
-          Conds:RS_17._col1=RS_18._col0(Left Semi),Output:["_col0","_col1","_col2"]
+      File Output Operator [FS_22]
+        Merge Join Operator [MERGEJOIN_27] (rows=6 width=227)
+          Conds:RS_18._col1=RS_19._col0(Left Semi),Output:["_col0","_col1","_col2"]
         <-Reducer 2 [SIMPLE_EDGE] llap
-          SHUFFLE [RS_17]
+          SHUFFLE [RS_18]
             PartitionCols:_col1
             Select Operator [SEL_6] (rows=13 width=227)
               Output:["_col0","_col1","_col2"]
-              Group By Operator [GBY_5] (rows=13 width=227)
-                Output:["_col0","_col1","_col2"],aggregations:["avg(VALUE._col0)"],keys:KEY._col0, KEY._col1
+              Group By Operator [GBY_5] (rows=13 width=235)
+                Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"],keys:KEY._col0, KEY._col1
               <-Map 1 [SIMPLE_EDGE] llap
                 SHUFFLE [RS_4]
                   PartitionCols:_col0, _col1
-                  Group By Operator [GBY_3] (rows=13 width=295)
-                    Output:["_col0","_col1","_col2"],aggregations:["avg(p_size)"],keys:p_name, p_mfgr
-                    Filter Operator [FIL_24] (rows=26 width=223)
+                  Group By Operator [GBY_3] (rows=13 width=235)
+                    Output:["_col0","_col1","_col2","_col3"],aggregations:["sum(p_size)","count(p_size)"],keys:p_name, p_mfgr
+                    Filter Operator [FIL_25] (rows=26 width=223)
                       predicate:p_name is not null
                       TableScan [TS_0] (rows=26 width=223)
                         default@part,part,Tbl:COMPLETE,Col:COMPLETE,Output:["p_name","p_mfgr","p_size"]
         <-Reducer 5 [SIMPLE_EDGE] llap
-          SHUFFLE [RS_18]
+          SHUFFLE [RS_19]
             PartitionCols:_col0
-            Group By Operator [GBY_16] (rows=13 width=184)
+            Group By Operator [GBY_17] (rows=13 width=184)
               Output:["_col0"],keys:_col0
-              Select Operator [SEL_11] (rows=26 width=184)
+              Select Operator [SEL_12] (rows=26 width=184)
                 Output:["_col0"]
-                Filter Operator [FIL_25] (rows=26 width=491)
+                Filter Operator [FIL_26] (rows=26 width=491)
                   predicate:first_value_window_0 is not null
-                  PTF Operator [PTF_10] (rows=26 width=491)
+                  PTF Operator [PTF_11] (rows=26 width=491)
                     Function definitions:[{},{"name:":"windowingtablefunction","order by:":"_col5 ASC NULLS FIRST","partition by:":"_col2"}]
-                    Select Operator [SEL_9] (rows=26 width=491)
+                    Select Operator [SEL_10] (rows=26 width=491)
                       Output:["_col1","_col2","_col5"]
                     <-Map 4 [SIMPLE_EDGE] llap
-                      SHUFFLE [RS_8]
+                      SHUFFLE [RS_9]
                         PartitionCols:p_mfgr
-                        TableScan [TS_7] (rows=26 width=223)
+                        TableScan [TS_8] (rows=26 width=223)
                           default@part,part,Tbl:COMPLETE,Col:COMPLETE,Output:["p_mfgr","p_name","p_size"]
 
 PREHOOK: query: explain select * 
@@ -2386,12 +2386,12 @@ Stage-0
                     PartitionCols:_col0
                     Select Operator [SEL_20] (rows=1 width=12)
                       Output:["_col0","_col1"]
-                      Group By Operator [GBY_7] (rows=1 width=8)
-                        Output:["_col0"],aggregations:["avg(VALUE._col0)"]
+                      Group By Operator [GBY_7] (rows=1 width=16)
+                        Output:["_col0","_col1"],aggregations:["sum(VALUE._col0)","count(VALUE._col1)"]
                       <-Map 5 [CUSTOM_SIMPLE_EDGE] llap
                         PARTITION_ONLY_SHUFFLE [RS_6]
-                          Group By Operator [GBY_5] (rows=1 width=76)
-                            Output:["_col0"],aggregations:["avg(p_size)"]
+                          Group By Operator [GBY_5] (rows=1 width=16)
+                            Output:["_col0","_col1"],aggregations:["sum(p_size)","count(p_size)"]
                             Filter Operator [FIL_33] (rows=8 width=4)
                               predicate:(p_size < 10)
                               TableScan [TS_2] (rows=26 width=4)
@@ -2405,7 +2405,9 @@ Stage-0
                       SHUFFLE [RS_22]
                         Group By Operator [GBY_12] (rows=1 width=16)
                           Output:["_col0","_col1"],aggregations:["count()","count(_col0)"]
-                           Please refer to the previous Group By Operator [GBY_7]
+                          Select Operator [SEL_8] (rows=1 width=16)
+                            Output:["_col0"]
+                             Please refer to the previous Group By Operator [GBY_7]
                     <-Map 1 [CUSTOM_SIMPLE_EDGE] llap
                       PARTITION_ONLY_SHUFFLE [RS_21]
                         Select Operator [SEL_1] (rows=26 width=125)
index d050c4e..05b5bfd 100644 (file)
@@ -54,13 +54,13 @@ STAGE PLANS:
                   alias: src
                   Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE
                   Select Operator
-                    expressions: substr(value, 5) (type: string)
-                    outputColumnNames: _col0
+                    expressions: value (type: string)
+                    outputColumnNames: value
                     Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE
                     Reduce Output Operator
-                      key expressions: _col0 (type: string)
+                      key expressions: substr(value, 5) (type: string)
                       sort order: +
-                      Map-reduce partition columns: _col0 (type: string)
+                      Map-reduce partition columns: substr(value, 5) (type: string)
                       Statistics: Num rows: 500 Data size: 45500 Basic stats: COMPLETE Column stats: COMPLETE
             Execution mode: llap
             LLAP IO: no inputs
index fe6b4f9..d1ac4e9 100644 (file)
@@ -296,39 +296,43 @@ STAGE PLANS:
                     outputColumnNames: _col0, _col1
                     Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(_col1)
+                      aggregations: sum(_col1), count(_col1)
                       keys: _col0 (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 250 Data size: 42750 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 42750 Basic stats: COMPLETE Column stats: COMPLETE
+                        Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
                         TopN Hash Memory Usage: 0.3
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:double>)
+                        value expressions: _col1 (type: double), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
-                Limit
-                  Number of rows: 20
-                  Statistics: Num rows: 20 Data size: 1980 Basic stats: COMPLETE Column stats: COMPLETE
-                  File Output Operator
-                    compressed: false
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: _col0 (type: string), (_col1 / _col2) (type: double)
+                  outputColumnNames: _col0, _col1
+                  Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
+                  Limit
+                    Number of rows: 20
                     Statistics: Num rows: 20 Data size: 1980 Basic stats: COMPLETE Column stats: COMPLETE
-                    table:
-                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                        serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+                    File Output Operator
+                      compressed: false
+                      Statistics: Num rows: 20 Data size: 1980 Basic stats: COMPLETE Column stats: COMPLETE
+                      table:
+                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                          serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
index 97686cb..960414b 100644 (file)
@@ -311,35 +311,39 @@ STAGE PLANS:
                     outputColumnNames: _col0, _col1
                     Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(_col1)
+                      aggregations: sum(_col1), count(_col1)
                       keys: _col0 (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 250 Data size: 42750 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 42750 Basic stats: COMPLETE Column stats: COMPLETE
+                        Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
                         TopN Hash Memory Usage: 0.3
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:double>)
+                        value expressions: _col1 (type: double), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
-                Reduce Output Operator
-                  key expressions: _col0 (type: string)
-                  sort order: +
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: _col0 (type: string), (_col1 / _col2) (type: double)
+                  outputColumnNames: _col0, _col1
                   Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
-                  TopN Hash Memory Usage: 0.3
-                  value expressions: _col1 (type: double)
+                  Reduce Output Operator
+                    key expressions: _col0 (type: string)
+                    sort order: +
+                    Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
+                    TopN Hash Memory Usage: 0.3
+                    value expressions: _col1 (type: double)
         Reducer 3 
             Execution mode: llap
             Reduce Operator Tree:
index cce6bc3..09a120a 100644 (file)
@@ -299,40 +299,44 @@ STAGE PLANS:
                     outputColumnNames: _col0, _col1
                     Statistics: Num rows: 500 Data size: 89000 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(_col1)
+                      aggregations: sum(_col1), count(_col1)
                       keys: _col0 (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 250 Data size: 42750 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: string)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: string)
-                        Statistics: Num rows: 250 Data size: 42750 Basic stats: COMPLETE Column stats: COMPLETE
+                        Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
                         TopN Hash Memory Usage: 0.3
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:double>)
+                        value expressions: _col1 (type: double), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
-                Limit
-                  Number of rows: 20
-                  Offset of rows: 10
-                  Statistics: Num rows: 20 Data size: 1980 Basic stats: COMPLETE Column stats: COMPLETE
-                  File Output Operator
-                    compressed: false
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 250 Data size: 26750 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: _col0 (type: string), (_col1 / _col2) (type: double)
+                  outputColumnNames: _col0, _col1
+                  Statistics: Num rows: 250 Data size: 24750 Basic stats: COMPLETE Column stats: COMPLETE
+                  Limit
+                    Number of rows: 20
+                    Offset of rows: 10
                     Statistics: Num rows: 20 Data size: 1980 Basic stats: COMPLETE Column stats: COMPLETE
-                    table:
-                        input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                        output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                        serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+                    File Output Operator
+                      compressed: false
+                      Statistics: Num rows: 20 Data size: 1980 Basic stats: COMPLETE Column stats: COMPLETE
+                      table:
+                          input format: org.apache.hadoop.mapred.SequenceFileInputFormat
+                          output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
+                          serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
 
   Stage: Stage-0
     Fetch Operator
index 1ccdff8..c786ba3 100644 (file)
@@ -191,34 +191,34 @@ STAGE PLANS:
                   alias: parquet_types
                   Statistics: Num rows: 22 Data size: 4576 Basic stats: COMPLETE Column stats: NONE
                   Select Operator
-                    expressions: cint (type: int), ctinyint (type: tinyint), csmallint (type: smallint), cfloat (type: float), cdouble (type: double), cstring1 (type: string)
-                    outputColumnNames: cint, ctinyint, csmallint, cfloat, cdouble, cstring1
+                    expressions: ctinyint (type: tinyint), cint (type: int), csmallint (type: smallint), cstring1 (type: string), cfloat (type: float), cdouble (type: double), (cdouble * cdouble) (type: double)
+                    outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6
                     Statistics: Num rows: 22 Data size: 4576 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: max(cint), min(csmallint), count(cstring1), avg(cfloat), stddev_pop(cdouble)
-                      keys: ctinyint (type: tinyint)
+                      aggregations: max(_col1), min(_col2), count(_col3), sum(_col4), count(_col4), sum(_col6), sum(_col5), count(_col5)
+                      keys: _col0 (type: tinyint)
                       mode: hash
-                      outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                      outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
                       Statistics: Num rows: 22 Data size: 4576 Basic stats: COMPLETE Column stats: NONE
                       Reduce Output Operator
                         key expressions: _col0 (type: tinyint)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: tinyint)
                         Statistics: Num rows: 22 Data size: 4576 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col1 (type: int), _col2 (type: smallint), _col3 (type: bigint), _col4 (type: struct<count:bigint,sum:double,input:float>), _col5 (type: struct<count:bigint,sum:double,variance:double>)
+                        value expressions: _col1 (type: int), _col2 (type: smallint), _col3 (type: bigint), _col4 (type: double), _col5 (type: bigint), _col6 (type: double), _col7 (type: double), _col8 (type: bigint)
             Execution mode: vectorized, llap
             LLAP IO: all inputs (cache only)
         Reducer 2 
-            Execution mode: llap
+            Execution mode: vectorized, llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: max(VALUE._col0), min(VALUE._col1), count(VALUE._col2), avg(VALUE._col3), stddev_pop(VALUE._col4)
+                aggregations: max(VALUE._col0), min(VALUE._col1), count(VALUE._col2), sum(VALUE._col3), count(VALUE._col4), sum(VALUE._col5), sum(VALUE._col6), count(VALUE._col7)
                 keys: KEY._col0 (type: tinyint)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
+                outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
                 Statistics: Num rows: 11 Data size: 2288 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
-                  expressions: _col0 (type: tinyint), _col1 (type: int), _col2 (type: smallint), _col3 (type: bigint), round(_col4, 5) (type: double), round(_col5, 5) (type: double)
+                  expressions: _col0 (type: tinyint), _col1 (type: int), _col2 (type: smallint), _col3 (type: bigint), round((_col4 / _col5), 5) (type: double), round(power(((_col6 - ((_col7 * _col7) / _col8)) / _col8), 0.5), 5) (type: double)
                   outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5
                   Statistics: Num rows: 11 Data size: 2288 Basic stats: COMPLETE Column stats: NONE
                   Reduce Output Operator
index 277036a..37b18f0 100644 (file)
@@ -360,30 +360,34 @@ STAGE PLANS:
                       outputColumnNames: _col0
                       Statistics: Num rows: 8 Data size: 2960 Basic stats: COMPLETE Column stats: COMPLETE
                       Group By Operator
-                        aggregations: avg(_col0)
+                        aggregations: sum(_col0), count(_col0)
                         mode: hash
-                        outputColumnNames: _col0
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                        outputColumnNames: _col0, _col1
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                         Reduce Output Operator
                           sort order: 
-                          Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                          value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                          Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                          value expressions: _col0 (type: bigint), _col1 (type: bigint)
         Reducer 5 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                 Filter Operator
-                  predicate: _col0 is not null (type: boolean)
-                  Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                  Reduce Output Operator
-                    key expressions: _col0 (type: double)
-                    sort order: +
-                    Map-reduce partition columns: _col0 (type: double)
+                  predicate: (_col0 is not null and _col1 is not null) (type: boolean)
+                  Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                  Select Operator
+                    expressions: (_col0 / _col1) (type: double)
+                    outputColumnNames: _col0
                     Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                    Reduce Output Operator
+                      key expressions: _col0 (type: double)
+                      sort order: +
+                      Map-reduce partition columns: _col0 (type: double)
+                      Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
 
   Stage: Stage-0
     Fetch Operator
@@ -1268,17 +1272,17 @@ STAGE PLANS:
                     predicate: l_partkey is not null (type: boolean)
                     Statistics: Num rows: 100 Data size: 1200 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(l_quantity)
+                      aggregations: sum(l_quantity), count(l_quantity)
                       keys: l_partkey (type: int)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 50 Data size: 4200 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: int)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: int)
-                        Statistics: Num rows: 50 Data size: 4200 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:double>)
+                        Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: double), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -1337,16 +1341,16 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: int)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 50 Data size: 600 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
                 Filter Operator
-                  predicate: _col1 is not null (type: boolean)
-                  Statistics: Num rows: 50 Data size: 600 Basic stats: COMPLETE Column stats: COMPLETE
+                  predicate: (_col1 is not null and _col2 is not null) (type: boolean)
+                  Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
                   Select Operator
-                    expressions: _col1 (type: double), _col0 (type: int)
+                    expressions: (_col1 / _col2) (type: double), _col0 (type: int)
                     outputColumnNames: _col0, _col1
                     Statistics: Num rows: 50 Data size: 600 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
@@ -4463,17 +4467,17 @@ STAGE PLANS:
                     predicate: p_partkey is not null (type: boolean)
                     Statistics: Num rows: 26 Data size: 208 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       keys: p_partkey (type: int)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 13 Data size: 1040 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: int)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: int)
-                        Statistics: Num rows: 13 Data size: 1040 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: bigint), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -4498,24 +4502,32 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: int)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 13 Data size: 156 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
                 Filter Operator
-                  predicate: _col1 is not null (type: boolean)
-                  Statistics: Num rows: 13 Data size: 156 Basic stats: COMPLETE Column stats: COMPLETE
-                  Group By Operator
-                    keys: _col0 (type: int), _col1 (type: double)
-                    mode: hash
+                  predicate: (_col1 is not null and _col2 is not null) (type: boolean)
+                  Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
+                  Select Operator
+                    expressions: (_col1 / _col2) (type: double), _col0 (type: int)
                     outputColumnNames: _col0, _col1
-                    Statistics: Num rows: 6 Data size: 72 Basic stats: COMPLETE Column stats: COMPLETE
-                    Reduce Output Operator
-                      key expressions: _col0 (type: int), _col1 (type: double)
-                      sort order: ++
-                      Map-reduce partition columns: _col0 (type: int), _col1 (type: double)
-                      Statistics: Num rows: 6 Data size: 72 Basic stats: COMPLETE Column stats: COMPLETE
+                    Statistics: Num rows: 13 Data size: 156 Basic stats: COMPLETE Column stats: COMPLETE
+                    Select Operator
+                      expressions: _col1 (type: int), _col0 (type: double)
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 13 Data size: 156 Basic stats: COMPLETE Column stats: COMPLETE
+                      Group By Operator
+                        keys: _col0 (type: int), _col1 (type: double)
+                        mode: hash
+                        outputColumnNames: _col0, _col1
+                        Statistics: Num rows: 6 Data size: 72 Basic stats: COMPLETE Column stats: COMPLETE
+                        Reduce Output Operator
+                          key expressions: _col0 (type: int), _col1 (type: double)
+                          sort order: ++
+                          Map-reduce partition columns: _col0 (type: int), _col1 (type: double)
+                          Statistics: Num rows: 6 Data size: 72 Basic stats: COMPLETE Column stats: COMPLETE
 
   Stage: Stage-0
     Fetch Operator
@@ -5051,23 +5063,23 @@ STAGE PLANS:
                     predicate: p_partkey is not null (type: boolean)
                     Statistics: Num rows: 26 Data size: 208 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       keys: p_partkey (type: int)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 13 Data size: 1040 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: int)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: int)
-                        Statistics: Num rows: 13 Data size: 1040 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: bigint), _col2 (type: bigint)
                       Reduce Output Operator
                         key expressions: _col0 (type: int)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: int)
-                        Statistics: Num rows: 13 Data size: 1040 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: bigint), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -5160,34 +5172,38 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: int)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 13 Data size: 156 Basic stats: COMPLETE Column stats: COMPLETE
-                Group By Operator
-                  aggregations: count(), count(_col1)
-                  keys: _col0 (type: int)
-                  mode: complete
-                  outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: _col0 (type: int), (_col1 / _col2) (type: double)
+                  outputColumnNames: _col0, _col1
                   Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
-                  Reduce Output Operator
-                    key expressions: _col0 (type: int)
-                    sort order: +
-                    Map-reduce partition columns: _col0 (type: int)
+                  Group By Operator
+                    aggregations: count(), count(_col1)
+                    keys: _col0 (type: int)
+                    mode: complete
+                    outputColumnNames: _col0, _col1, _col2
                     Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
-                    value expressions: _col1 (type: bigint), _col2 (type: bigint)
+                    Reduce Output Operator
+                      key expressions: _col0 (type: int)
+                      sort order: +
+                      Map-reduce partition columns: _col0 (type: int)
+                      Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
+                      value expressions: _col1 (type: bigint), _col2 (type: bigint)
         Reducer 9 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: int)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 13 Data size: 156 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 13 Data size: 260 Basic stats: COMPLETE Column stats: COMPLETE
                 Select Operator
-                  expressions: _col1 (type: double), _col0 (type: int)
+                  expressions: (_col1 / _col2) (type: double), _col0 (type: int)
                   outputColumnNames: _col0, _col1
                   Statistics: Num rows: 13 Data size: 208 Basic stats: COMPLETE Column stats: COMPLETE
                   Filter Operator
index 390caf0..79857ab 100644 (file)
@@ -279,17 +279,17 @@ STAGE PLANS:
                     predicate: p_mfgr is not null (type: boolean)
                     Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       keys: p_mfgr (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1
+                      outputColumnNames: _col0, _col1, _col2
                       Statistics: Num rows: 1 Data size: 188 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: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                        value expressions: _col1 (type: bigint), _col2 (type: bigint)
                     Group By Operator
                       aggregations: max(p_size), min(p_size)
                       keys: p_mfgr (type: string)
@@ -308,17 +308,21 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
+                outputColumnNames: _col0, _col1, _col2
                 Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                Reduce Output Operator
-                  key expressions: _col0 (type: string)
-                  sort order: +
-                  Map-reduce partition columns: _col0 (type: string)
+                Select Operator
+                  expressions: _col0 (type: string), (_col1 / _col2) (type: double)
+                  outputColumnNames: _col0, _col1
                   Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: double)
+                  Reduce Output Operator
+                    key expressions: _col0 (type: string)
+                    sort order: +
+                    Map-reduce partition columns: _col0 (type: string)
+                    Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
+                    value expressions: _col1 (type: double)
         Reducer 3 
             Execution mode: llap
             Reduce Operator Tree:
@@ -410,17 +414,17 @@ STAGE PLANS:
                     predicate: p_mfgr is not null (type: boolean)
                     Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       keys: p_mfgr (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1
+                      outputColumnNames: _col0, _col1, _col2
                       Statistics: Num rows: 1 Data size: 188 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: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                        value expressions: _col1 (type: bigint), _col2 (type: bigint)
                     Group By Operator
                       aggregations: max(p_size), min(p_size)
                       keys: p_mfgr (type: string)
@@ -439,17 +443,21 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
+                outputColumnNames: _col0, _col1, _col2
                 Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                Reduce Output Operator
-                  key expressions: _col0 (type: string)
-                  sort order: +
-                  Map-reduce partition columns: _col0 (type: string)
+                Select Operator
+                  expressions: _col0 (type: string), (_col1 / _col2) (type: double)
+                  outputColumnNames: _col0, _col1
                   Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col1 (type: double)
+                  Reduce Output Operator
+                    key expressions: _col0 (type: string)
+                    sort order: +
+                    Map-reduce partition columns: _col0 (type: string)
+                    Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
+                    value expressions: _col1 (type: double)
         Reducer 3 
             Execution mode: llap
             Reduce Operator Tree:
@@ -1432,17 +1440,17 @@ STAGE PLANS:
                     predicate: p_name is not null (type: boolean)
                     Statistics: Num rows: 1 Data size: 372 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       keys: p_name (type: string), p_mfgr (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1, _col2
+                      outputColumnNames: _col0, _col1, _col2, _col3
                       Statistics: Num rows: 1 Data size: 372 Basic stats: COMPLETE Column stats: NONE
                       Reduce Output Operator
                         key expressions: _col0 (type: string), _col1 (type: string)
                         sort order: ++
                         Map-reduce partition columns: _col0 (type: string), _col1 (type: string)
                         Statistics: Num rows: 1 Data size: 372 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col2 (type: struct<count:bigint,sum:double,input:int>)
+                        value expressions: _col2 (type: bigint), _col3 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Map 3 
@@ -1462,13 +1470,13 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string), KEY._col1 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1, _col2
+                outputColumnNames: _col0, _col1, _col2, _col3
                 Statistics: Num rows: 1 Data size: 372 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
-                  expressions: _col1 (type: string), _col0 (type: string), _col2 (type: double)
+                  expressions: _col1 (type: string), _col0 (type: string), (_col2 / _col3) (type: double)
                   outputColumnNames: _col0, _col1, _col2
                   Statistics: Num rows: 1 Data size: 372 Basic stats: COMPLETE Column stats: NONE
                   Map Join Operator
index 438e444..24f18e9 100644 (file)
@@ -2888,35 +2888,39 @@ STAGE PLANS:
                     outputColumnNames: l_quantity
                     Statistics: Num rows: 100 Data size: 800 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(l_quantity)
+                      aggregations: sum(l_quantity), count(l_quantity)
                       mode: hash
-                      outputColumnNames: _col0
-                      Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         sort order: 
-                        Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col0 (type: struct<count:bigint,sum:double,input:double>)
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col0 (type: double), _col1 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 10 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                Group By Operator
-                  aggregations: count(), count(_col0)
-                  mode: complete
-                  outputColumnNames: _col0, _col1
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
                   Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
-                  Reduce Output Operator
-                    sort order: 
+                  Group By Operator
+                    aggregations: count(), count(_col0)
+                    mode: complete
+                    outputColumnNames: _col0, _col1
                     Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
-                    value expressions: _col0 (type: bigint), _col1 (type: bigint)
+                    Reduce Output Operator
+                      sort order: 
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                      value expressions: _col0 (type: bigint), _col1 (type: bigint)
                 Select Operator
-                  expressions: _col0 (type: double), true (type: boolean)
+                  expressions: (_col0 / _col1) (type: double), true (type: boolean)
                   outputColumnNames: _col0, _col1
                   Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE
                   Reduce Output Operator
index 851a783..7b8e87a 100644 (file)
@@ -715,14 +715,14 @@ STAGE PLANS:
                       outputColumnNames: _col0
                       Statistics: Num rows: 8 Data size: 2960 Basic stats: COMPLETE Column stats: COMPLETE
                       Group By Operator
-                        aggregations: avg(_col0)
+                        aggregations: sum(_col0), count(_col0)
                         mode: hash
-                        outputColumnNames: _col0
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                        outputColumnNames: _col0, _col1
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                         Reduce Output Operator
                           sort order: 
-                          Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                          value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                          Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                          value expressions: _col0 (type: bigint), _col1 (type: bigint)
                 PTF Operator
                   Function definitions:
                       Input definition
@@ -752,41 +752,45 @@ STAGE PLANS:
                       outputColumnNames: _col0
                       Statistics: Num rows: 8 Data size: 2960 Basic stats: COMPLETE Column stats: COMPLETE
                       Group By Operator
-                        aggregations: avg(_col0)
+                        aggregations: sum(_col0), count(_col0)
                         mode: hash
-                        outputColumnNames: _col0
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                        outputColumnNames: _col0, _col1
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                         Reduce Output Operator
                           sort order: 
-                          Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                          value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                          Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                          value expressions: _col0 (type: bigint), _col1 (type: bigint)
         Reducer 6 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                Group By Operator
-                  aggregations: count(), count(_col0)
-                  mode: complete
-                  outputColumnNames: _col0, _col1
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
                   Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
-                  Reduce Output Operator
-                    sort order: 
+                  Group By Operator
+                    aggregations: count(), count(_col0)
+                    mode: complete
+                    outputColumnNames: _col0, _col1
                     Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
-                    value expressions: _col0 (type: bigint), _col1 (type: bigint)
+                    Reduce Output Operator
+                      sort order: 
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                      value expressions: _col0 (type: bigint), _col1 (type: bigint)
         Reducer 7 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                 Select Operator
-                  expressions: _col0 (type: double), true (type: boolean)
+                  expressions: (_col0 / _col1) (type: double), true (type: boolean)
                   outputColumnNames: _col0, _col1
                   Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE
                   Reduce Output Operator
index 1483651..4a8c9b1 100644 (file)
@@ -122,14 +122,14 @@ STAGE PLANS:
                     outputColumnNames: p_size
                     Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       mode: hash
-                      outputColumnNames: _col0
-                      Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: NONE
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE
                       Reduce Output Operator
                         sort order: 
-                        Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE
+                        value expressions: _col0 (type: bigint), _col1 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -143,14 +143,14 @@ STAGE PLANS:
                   1 
                 outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8, _col9
                 residual filter predicates: {(UDFToDouble(_col5) > _col9)}
-                Statistics: Num rows: 8 Data size: 5600 Basic stats: COMPLETE Column stats: NONE
+                Statistics: Num rows: 8 Data size: 5120 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
                   expressions: _col0 (type: int), _col1 (type: string), _col2 (type: string), _col3 (type: string), _col4 (type: string), _col5 (type: int), _col6 (type: string), _col7 (type: double), _col8 (type: string)
                   outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7, _col8
-                  Statistics: Num rows: 8 Data size: 5600 Basic stats: COMPLETE Column stats: NONE
+                  Statistics: Num rows: 8 Data size: 5120 Basic stats: COMPLETE Column stats: NONE
                   File Output Operator
                     compressed: false
-                    Statistics: Num rows: 8 Data size: 5600 Basic stats: COMPLETE Column stats: NONE
+                    Statistics: Num rows: 8 Data size: 5120 Basic stats: COMPLETE Column stats: NONE
                     table:
                         input format: org.apache.hadoop.mapred.SequenceFileInputFormat
                         output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
@@ -159,14 +159,18 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: NONE
-                Reduce Output Operator
-                  sort order: 
-                  Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: NONE
-                  value expressions: _col0 (type: double)
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
+                  Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE
+                  Reduce Output Operator
+                    sort order: 
+                    Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: NONE
+                    value expressions: _col0 (type: double)
 
   Stage: Stage-0
     Fetch Operator
@@ -826,14 +830,14 @@ STAGE PLANS:
                         Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: COMPLETE
                         value expressions: _col0 (type: int)
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       mode: hash
-                      outputColumnNames: _col0
-                      Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         sort order: 
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col0 (type: bigint), _col1 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -892,14 +896,18 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                Reduce Output Operator
-                  sort order: 
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
                   Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                  value expressions: _col0 (type: double)
+                  Reduce Output Operator
+                    sort order: 
+                    Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: double)
 
   Stage: Stage-0
     Fetch Operator
@@ -1595,17 +1603,17 @@ STAGE PLANS:
                     predicate: p_type is not null (type: boolean)
                     Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       keys: p_type (type: string)
                       mode: hash
-                      outputColumnNames: _col0, _col1
+                      outputColumnNames: _col0, _col1, _col2
                       Statistics: Num rows: 1 Data size: 188 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: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                        value expressions: _col1 (type: bigint), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -1635,13 +1643,13 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: string)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
+                outputColumnNames: _col0, _col1, _col2
                 Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
                 Select Operator
-                  expressions: _col1 (type: double), true (type: boolean), _col0 (type: string)
+                  expressions: (_col1 / _col2) (type: double), true (type: boolean), _col0 (type: string)
                   outputColumnNames: _col0, _col1, _col2
                   Statistics: Num rows: 1 Data size: 188 Basic stats: COMPLETE Column stats: NONE
                   Reduce Output Operator
@@ -4177,17 +4185,17 @@ STAGE PLANS:
                     predicate: l_partkey is not null (type: boolean)
                     Statistics: Num rows: 100 Data size: 1200 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(l_quantity)
+                      aggregations: sum(l_quantity), count(l_quantity)
                       keys: l_partkey (type: int)
                       mode: hash
-                      outputColumnNames: _col0, _col1
-                      Statistics: Num rows: 50 Data size: 4200 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1, _col2
+                      Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         key expressions: _col0 (type: int)
                         sort order: +
                         Map-reduce partition columns: _col0 (type: int)
-                        Statistics: Num rows: 50 Data size: 4200 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col1 (type: struct<count:bigint,sum:double,input:double>)
+                        Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col1 (type: double), _col2 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Reducer 2 
@@ -4236,13 +4244,13 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: int)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 50 Data size: 600 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 50 Data size: 1000 Basic stats: COMPLETE Column stats: COMPLETE
                 Select Operator
-                  expressions: _col1 (type: double), _col0 (type: int)
+                  expressions: (_col1 / _col2) (type: double), _col0 (type: int)
                   outputColumnNames: _col0, _col1
                   Statistics: Num rows: 50 Data size: 600 Basic stats: COMPLETE Column stats: COMPLETE
                   Reduce Output Operator
@@ -6328,29 +6336,29 @@ STAGE PLANS:
                   outputColumnNames: _col0, _col2
                   Statistics: Num rows: 2 Data size: 24 Basic stats: COMPLETE Column stats: COMPLETE
                   Group By Operator
-                    aggregations: avg(_col0)
+                    aggregations: sum(_col0), count(_col0)
                     keys: _col2 (type: int)
                     mode: hash
-                    outputColumnNames: _col0, _col1
-                    Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: COMPLETE
+                    outputColumnNames: _col0, _col1, _col2
+                    Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: COMPLETE
                     Reduce Output Operator
                       key expressions: _col0 (type: int)
                       sort order: +
                       Map-reduce partition columns: _col0 (type: int)
-                      Statistics: Num rows: 1 Data size: 80 Basic stats: COMPLETE Column stats: COMPLETE
-                      value expressions: _col1 (type: struct<count:bigint,sum:double,input:int>)
+                      Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: COMPLETE
+                      value expressions: _col1 (type: bigint), _col2 (type: bigint)
         Reducer 4 
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 keys: KEY._col0 (type: int)
                 mode: mergepartial
-                outputColumnNames: _col0, _col1
-                Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE
+                outputColumnNames: _col0, _col1, _col2
+                Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: COMPLETE
                 Filter Operator
-                  predicate: (_col1 = 0.0D) (type: boolean)
-                  Statistics: Num rows: 1 Data size: 12 Basic stats: COMPLETE Column stats: COMPLETE
+                  predicate: (0.0D = (_col1 / _col2)) (type: boolean)
+                  Statistics: Num rows: 1 Data size: 20 Basic stats: COMPLETE Column stats: COMPLETE
                   Select Operator
                     expressions: _col0 (type: int)
                     outputColumnNames: _col0
index abbfffd..8ad0705 100644 (file)
@@ -3815,14 +3815,14 @@ STAGE PLANS:
                     predicate: p_partkey BETWEEN 1 AND 20 (type: boolean)
                     Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(p_partkey)
+                      aggregations: sum(p_partkey), count(p_partkey)
                       mode: hash
-                      outputColumnNames: _col0
-                      Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         sort order: 
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col0 (type: bigint), _col1 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Map 9 
@@ -3928,14 +3928,18 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                Reduce Output Operator
-                  sort order: 
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
                   Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                  value expressions: _col0 (type: double)
+                  Reduce Output Operator
+                    sort order: 
+                    Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: double)
 
   Stage: Stage-0
     Fetch Operator
@@ -4175,14 +4179,14 @@ STAGE PLANS:
                     outputColumnNames: p_size
                     Statistics: Num rows: 26 Data size: 104 Basic stats: COMPLETE Column stats: COMPLETE
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       mode: hash
-                      outputColumnNames: _col0
-                      Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         sort order: 
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col0 (type: bigint), _col1 (type: bigint)
             Execution mode: llap
             LLAP IO: no inputs
         Map 6 
@@ -4254,14 +4258,18 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                Reduce Output Operator
-                  sort order: 
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
                   Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                  value expressions: _col0 (type: double)
+                  Reduce Output Operator
+                    sort order: 
+                    Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: double)
         Reducer 7 
             Execution mode: llap
             Reduce Operator Tree:
@@ -4386,14 +4394,14 @@ STAGE PLANS:
                         Statistics: Num rows: 1 Data size: 4 Basic stats: COMPLETE Column stats: COMPLETE
                         value expressions: _col0 (type: int)
                     Group By Operator
-                      aggregations: avg(p_size)
+                      aggregations: sum(p_size), count(p_size)
                       mode: hash
-                      outputColumnNames: _col0
-                      Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
+                      outputColumnNames: _col0, _col1
+                      Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
                       Reduce Output Operator
                         sort order: 
-                        Statistics: Num rows: 1 Data size: 76 Basic stats: COMPLETE Column stats: COMPLETE
-                        value expressions: _col0 (type: struct<count:bigint,sum:double,input:int>)
+                        Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                        value expressions: _col0 (type: bigint), _col1 (type: bigint)
                     Group By Operator
                       aggregations: sum(p_size)
                       mode: hash
@@ -4512,14 +4520,18 @@ STAGE PLANS:
             Execution mode: llap
             Reduce Operator Tree:
               Group By Operator
-                aggregations: avg(VALUE._col0)
+                aggregations: sum(VALUE._col0), count(VALUE._col1)
                 mode: mergepartial
-                outputColumnNames: _col0
-                Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                Reduce Output Operator
-                  sort order: 
+                outputColumnNames: _col0, _col1
+                Statistics: Num rows: 1 Data size: 16 Basic stats: COMPLETE Column stats: COMPLETE
+                Select Operator
+                  expressions: (_col0 / _col1) (type: double)
+                  outputColumnNames: _col0
                   Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
-                  value expressions: _col0 (type: double)
+                  Reduce Output Operator
+                    sort order: 
+                    Statistics: Num rows: 1 Data size: 8 Basic stats: COMPLETE Column stats: COMPLETE
+                    value expressions: _col0 (type: double)
 
   Stage: Stage-0
     Fetch Operator
index 5d4bfe7..1e090f0 100644 (file)
@@ -140,9 +140,9 @@ STAGE PLANS:
                         projectedOutputColumnNums: [6]
                     Statistics: Num rows: 2000 Data size: 212912 Basic stats: COMPLETE Column stats: NONE
                     Group By Operator
-                      aggregations: min(dc), max(dc), sum(dc), avg(dc)
+                      aggregations: min(dc), max(dc), sum(dc), count(dc)
                       Group By Vectorization:
-                          aggregators: VectorUDAFMinDecimal(col 6:decimal(38,18)) -> decimal(38,18), VectorUDAFMaxDecimal(col 6:decimal(38,18)) -> decimal(38,18), VectorUDAFSumDecimal(col 6:decimal(38,18)) -> decimal(38,18), VectorUDAFAvgDecimal(col 6:decimal(38,18)) -> struct<count:bigint,sum:decimal(38,18),input:decimal(38,18)>
+                          aggregators: VectorUDAFMinDecimal(col 6:decimal(38,18)) -> decimal(38,18), VectorUDAFMaxDecimal(col 6:decimal(38,18)) -> decimal(38,18), VectorUDAFSumDecimal(col 6:decimal(38,18)) -> decimal(38,18), VectorUDAFCount(col 6:decimal(38,18)) -> bigint
                           className: VectorGroupByOperator
                           groupByMode: HASH
                           native: false
@@ -150,7 +150,7 @@ STAGE PLANS:
                           projectedOutputColumnNums: [0, 1, 2, 3]
                       mode: hash
                       outputColumnNames: _col0, _col1, _col2, _col3
-                      Statistics: Num rows: 1 Data size: 736 Basic stats: COMPLETE Column stats: NONE
+                      Statistics: Num rows: 1 Data size: 456 Basic stats: COMPLETE Column stats: NONE
                       Reduce Output Operator
                         sort order: 
                         Reduce Sink Vectorization:
@@ -159,8 +159,8 @@ STAGE PLANS:
                             native: true
                             nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No PTF TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true
                             valueColumnNums: [0, 1, 2, 3]
-                        Statistics: Num rows: 1 Data size: 736 Basic stats: COMPLETE Column stats: NONE
-                        value expressions: _col0 (type: decimal(38,18)), _col1 (type: decimal(38,18)), _col2 (type: decimal(38,18)), _col3 (type: struct<count:bigint,sum:decimal(38,18),input:decimal(38,18)>)
+                        Statistics: Num rows: 1 Data size: 456 Basic stats: COMPLETE Column stats: NONE
+                        value expressions: _col0 (type: decimal(38,18)), _col1 (type: decimal(38,18)), _col2 (type: decimal(38,18)), _col3 (type: bigint)
             Execution mode: vectorized, llap
             LLAP IO: all inputs
             Map Vectorization:
@@ -190,14 +190,14 @@ STAGE PLANS:
                 vectorized: true
                 rowBatchContext:
                     dataColumnCount: 4
-                    dataColumns: VALUE._col0:decimal(38,18), VALUE._col1:decimal(38,18), VALUE._col2:decimal(38,18), VALUE._col3:struct<count:bigint,sum:decimal(38,18),input:decimal(38,18)>
+                    dataColumns: VALUE._col0:decimal(38,18), VALUE._col1:decimal(38,18), VALUE._col2:decimal(38,18), VALUE._col3:bigint
                     partitionColumnCount: 0
                     scratchColumnTypeNames: []
             Reduce Operator Tree:
               Group By Operator
-                aggregations: min(VALUE._col0), max(VALUE._col1), sum(VALUE._col2), avg(VALUE._col3)
+                aggregations: min(VALUE._col0), max(VALUE._col1), sum(VALUE._col2), count(VALUE._col3)
                 Group By Vectorization:
-                    aggregators: VectorUDAFMinDecimal(col 0:decimal(38,18)) -> decimal(38,18), VectorUDAFMaxDecimal(col 1:decimal(38,18)) -> decimal(38,18), VectorUDAFSumDecimal(col 2:decimal(38,18)) -> decimal(38,18), VectorUDAFAvgDecimalFinal(col 3:struct<count:bigint,sum:decimal(38,18),input:decimal(38,18)>) -> decimal(38,18)
+                    aggregators: VectorUDAFMinDecimal(col 0:decimal(38,18)) -> decimal(38,18), VectorUDAFMaxDecimal(col 1:decimal(38,18)) -> decimal(38,18), VectorUDAFSumDecimal(col 2:decimal(38,18)) -> decimal(38,18), VectorUDAFCountMerge(col 3:bigint) -> bigint
                     className: VectorGroupByOperator
                     groupByMode: MERGEPARTIAL
                     native: false
@@ -205,17 +205,26 @@ STAGE PLANS:
                     projectedOutputColumnNums: [0, 1, 2, 3]
                 mode: mergepartial
                 outputColumnNames: _col0, _col1, _col2, _col3
-                Statistics: Num rows: 1 Data size: 736 Basic stats: COMPLETE Column stats: NONE
-                File Output Operator
-                  compressed: false
-                  File Sink Vectorization:
-                      className: VectorFileSinkOperator
-                      native: false
-                  Statistics: Num rows: 1 Data size: 736 Basic stats: COMPLETE Column stats: NONE
-                  table:
-                      input format: org.apache.hadoop.mapred.SequenceFileInputFormat
-                      output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat
-                      serde: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
+                Statistics: Num rows: 1 Data size: 456 Basic stats: COMPLETE Column stats: NONE
+                Select Operator
+                  expressions: _col0 (type: decimal(38,18)), _col1 (type: decimal(38,18)), _col2 (type: decimal(38,18)), (_col2 / _col3) (type: decimal(38,18))
+                  outputColumnNames: _col0, _col1, _col2, _col3
+                  Select Vectorization:
+                      className: VectorSelectOperator
+                      native: true
+                      projectedOutputColumnNums: [0, 1, 2, 5]
+                      selectExpressions: DecimalColDivideDecimalColumn(col 2:decimal(38,18), col