diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt index 4393c3b..1378ad1 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvg.txt @@ -30,6 +30,7 @@ import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.hive.serde2.io.DoubleWritable; @@ -38,6 +39,8 @@ import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import com.google.common.base.Preconditions; + /** * Generated from template VectorUDAFAvg.txt. */ @@ -46,7 +49,7 @@ import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectIn public class extends VectorAggregateExpression { private static final long serialVersionUID = 1L; - + /** class for storing the current aggregate value. */ static class Aggregation implements AggregationBuffer { @@ -59,10 +62,10 @@ public class extends VectorAggregateExpression { * Value is explicitly (re)initialized in reset() */ transient private boolean isNull = true; - + public void sumValue( value) { if (isNull) { - sum = value; + sum = value; count = 1; isNull = false; } else { @@ -75,7 +78,7 @@ public class extends VectorAggregateExpression { public int getVariableSize() { throw new UnsupportedOperationException(); } - + @Override public void reset () { isNull = true; @@ -83,34 +86,55 @@ public class extends VectorAggregateExpression { count = 0L; } } - + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { return inputExpression; } +#IF PARTIAL1 transient private Object[] partialResult; transient private LongWritable resultCount; transient private DoubleWritable resultSum; transient private StructObjectInspector soi; - - public (VectorExpression inputExpression) { +#ENDIF PARTIAL1 +#IF COMPLETE + transient private DoubleWritable fullResult; + transient private ObjectInspector oi; +#ENDIF COMPLETE + + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; +#IF PARTIAL1 + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.PARTIAL1); +#ENDIF PARTIAL1 +#IF COMPLETE + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.COMPLETE); +#ENDIF COMPLETE } public () { super(); +#IF PARTIAL1 partialResult = new Object[2]; resultCount = new LongWritable(); resultSum = new DoubleWritable(); partialResult[0] = resultCount; partialResult[1] = resultSum; initPartialResultInspector(); +#ENDIF PARTIAL1 +#IF COMPLETE + fullResult = new DoubleWritable(); + initFullResultInspector(); +#ENDIF COMPLETE } +#IF PARTIAL1 private void initPartialResultInspector() { List foi = new ArrayList(); foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); @@ -120,7 +144,13 @@ public class extends VectorAggregateExpression { fname.add("sum"); soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); } - +#ENDIF PARTIAL1 +#IF COMPLETE + private void initFullResultInspector() { + oi = PrimitiveObjectInspectorFactory.writableDoubleObjectInspector; + } +#ENDIF COMPLETE + private Aggregation getCurrentAggregationBuffer( VectorAggregationBufferRow[] aggregationBufferSets, int bufferIndex, @@ -129,21 +159,21 @@ public class extends VectorAggregateExpression { Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); return myagg; } - + @Override public void aggregateInputSelection( VectorAggregationBufferRow[] aggregationBufferSets, int bufferIndex, VectorizedRowBatch batch) throws HiveException { - + int batchSize = batch.size; - + if (batchSize == 0) { return; } - + inputExpression.evaluate(batch); - + inputVector = ( )batch. cols[this.inputExpression.getOutputColumn()]; [] vector = inputVector.vector; @@ -210,10 +240,10 @@ public class extends VectorAggregateExpression { [] values, int[] selection, int batchSize) { - + for (int i=0; i < batchSize; ++i) { Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, + aggregationBufferSets, bufferIndex, i); myagg.sumValue(values[selection[i]]); @@ -245,7 +275,7 @@ public class extends VectorAggregateExpression { if (isNull[0]) { return; } - + for (int i=0; i < batchSize; ++i) { Aggregation myagg = getCurrentAggregationBuffer( aggregationBufferSets, @@ -253,7 +283,7 @@ public class extends VectorAggregateExpression { i); myagg.sumValue(value); } - + } private void iterateHasNullsRepeatingWithAggregationSelection( @@ -314,60 +344,56 @@ public class extends VectorAggregateExpression { } } - @Override - public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) throws HiveException { - - inputExpression.evaluate(batch); - - inputVector = - ()batch.cols[this.inputExpression.getOutputColumn()]; - - int batchSize = batch.size; - - if (batchSize == 0) { - return; - } - - Aggregation myagg = (Aggregation)agg; - - [] vector = inputVector.vector; - - if (inputVector.isRepeating) { - if (inputVector.noNulls) { - if (myagg.isNull) { - myagg.isNull = false; - myagg.sum = 0; - myagg.count = 0; - } - myagg.sum += vector[0]*batchSize; - myagg.count += batchSize; + + inputExpression.evaluate(batch); + + inputVector = + ()batch.cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + [] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; } - return; - } - - if (!batch.selectedInUse && inputVector.noNulls) { - iterateNoSelectionNoNulls(myagg, vector, batchSize); - } - else if (!batch.selectedInUse) { - iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); - } - else if (inputVector.noNulls){ - iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); - } - else { - iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + myagg.sum += vector[0]*batchSize; + myagg.count += batchSize; } + return; + } + + if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNulls(myagg, vector, batchSize); + } else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); + } else if (inputVector.noNulls){ + iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); + } else { + iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + } } - + private void iterateSelectionHasNulls( - Aggregation myagg, - [] vector, + Aggregation myagg, + [] vector, int batchSize, - boolean[] isNull, + boolean[] isNull, int[] selected) { - + for (int j=0; j< batchSize; ++j) { int i = selected[j]; if (!isNull[i]) { @@ -384,17 +410,17 @@ public class extends VectorAggregateExpression { } private void iterateSelectionNoNulls( - Aggregation myagg, - [] vector, - int batchSize, + Aggregation myagg, + [] vector, + int batchSize, int[] selected) { - + if (myagg.isNull) { myagg.isNull = false; myagg.sum = 0; myagg.count = 0; } - + for (int i=0; i< batchSize; ++i) { value = vector[selected[i]]; myagg.sum += value; @@ -403,15 +429,15 @@ public class extends VectorAggregateExpression { } private void iterateNoSelectionHasNulls( - Aggregation myagg, - [] vector, + Aggregation myagg, + [] vector, int batchSize, boolean[] isNull) { - + for(int i=0;i value = vector[i]; - if (myagg.isNull) { + if (myagg.isNull) { myagg.isNull = false; myagg.sum = 0; myagg.count = 0; @@ -431,7 +457,7 @@ public class extends VectorAggregateExpression { myagg.sum = 0; myagg.count = 0; } - + for (int i=0;i value = vector[i]; myagg.sum += value; @@ -459,16 +485,27 @@ public class extends VectorAggregateExpression { } else { assert(0 < myagg.count); +#IF PARTIAL1 resultCount.set (myagg.count); resultSum.set (myagg.sum); return partialResult; +#ENDIF PARTIAL1 +#IF COMPLETE + fullResult.set (myagg.sum / myagg.count); + return fullResult; +#ENDIF COMPLETE } } - + @Override public ObjectInspector getOutputObjectInspector() { +#IF PARTIAL1 return soi; - } +#ENDIF PARTIAL1 +#IF COMPLETE + return oi; +#ENDIF COMPLETE + } @Override public int getAggregationBufferFixedSize() { @@ -483,7 +520,7 @@ public class extends VectorAggregateExpression { public void init(AggregationDesc desc) throws HiveException { // No-op } - + public VectorExpression getInputExpression() { return inputExpression; } @@ -491,5 +528,4 @@ public class extends VectorAggregateExpression { public void setInputExpression(VectorExpression inputExpression) { this.inputExpression = inputExpression; } -} - +} \ No newline at end of file diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvgDecimal.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvgDecimal.txt new file mode 100644 index 0000000..c90a9c8 --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvgDecimal.txt @@ -0,0 +1,578 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.hive.common.type.HiveDecimal; +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFAverage; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFAverage.GenericUDAFAverageEvaluatorDecimal; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo; +import org.apache.hadoop.hive.serde2.typeinfo.TypeInfoFactory; + +import com.google.common.base.Preconditions; + +/** + * Generated from template VectorUDAFAvg.txt. + */ +@Description(name = "avg", + value = "_FUNC_(AVG) - Returns the average value of expr (vectorized, type: decimal)") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** class for storing the current aggregate value. */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private final HiveDecimalWritable sum = new HiveDecimalWritable(); + transient private long count; + transient private boolean isNull; + + public void sumValueWithNullCheck(HiveDecimalWritable writable) { + if (isNull) { + // Make a copy since we intend to mutate sum. + sum.set(writable); + count = 1; + isNull = false; + } else { + // Note that if sum is out of range, mutateAdd will ignore the call. + // At the end, sum.isSet() can be checked for null. + sum.mutateAdd(writable); + count++; + } + } + + public void sumValueNoNullCheck(HiveDecimalWritable writable) { + sum.mutateAdd(writable); + count++; + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + + @Override + public void reset() { + isNull = true; + sum.setFromLong(0L); + count = 0; + } + } + + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; + + @Override + public VectorExpression inputExpression() { + return inputExpression; + } + +#IF PARTIAL1 + transient private Object[] partialResult; + transient private LongWritable resultCount; + transient private HiveDecimalWritable resultSum; + transient private StructObjectInspector soi; +#ENDIF PARTIAL1 +#IF COMPLETE + transient private HiveDecimalWritable tempDecWritable; + transient private HiveDecimalWritable fullResult; + transient private ObjectInspector oi; +#ENDIF COMPLETE + + /** + * The scale of the SUM in the partial output + */ + private int sumScale; + + /** + * The precision of the SUM in the partial output + */ + private int sumPrecision; + + /** + * the scale of the input expression + */ + private int inputScale; + + /** + * the precision of the input expression + */ + private int inputPrecision; + + public (VectorExpression inputExpression, + GenericUDAFEvaluator.Mode mode) { + this(); + this.inputExpression = inputExpression; + this.mode = mode; +#IF PARTIAL1 + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.PARTIAL1); +#ENDIF PARTIAL1 +#IF COMPLETE + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.COMPLETE); +#ENDIF COMPLETE + } + + public () { + super(); +#IF PARTIAL1 + partialResult = new Object[2]; + resultCount = new LongWritable(); + resultSum = new HiveDecimalWritable(); + partialResult[0] = resultCount; + partialResult[1] = resultSum; +#ENDIF PARTIAL1 +#IF COMPLETE + tempDecWritable = new HiveDecimalWritable(); + fullResult = new HiveDecimalWritable(); +#ENDIF COMPLETE + } + +#IF PARTIAL1 + private void initPartialResultInspector() { +#ENDIF PARTIAL1 +#IF COMPLETE + private void initFullResultInspector() { +#ENDIF COMPLETE + // the output type of the vectorized partial aggregate must match the + // expected type for the row-mode aggregation + // For decimal, the type is "same number of integer digits and 4 more decimal digits" + + DecimalTypeInfo decTypeInfo = + GenericUDAFAverageEvaluatorDecimal.deriveResultDecimalTypeInfo( + inputPrecision, inputScale, mode); + this.sumScale = decTypeInfo.scale(); + this.sumPrecision = decTypeInfo.precision(); + +#IF PARTIAL1 + List foi = new ArrayList(); + foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(decTypeInfo)); + List fname = new ArrayList(); + fname.add("count"); + fname.add("sum"); + soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); +#ENDIF PARTIAL1 +#IF COMPLETE + oi = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(decTypeInfo); +#ENDIF COMPLETE + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + DecimalColumnVector inputVector = (DecimalColumnVector) batch. + cols[this.inputExpression.getOutputColumn()]; + HiveDecimalWritable[] vector = inputVector.vector; + + if (inputVector.noNulls) { + if (inputVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector[0], batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batchSize); + } + } + } else { + if (inputVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector[0], batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector[0], batchSize, inputVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batchSize, batch.selected, inputVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + vector, batchSize, inputVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable value, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValueWithNullCheck(value); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable[] values, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValueWithNullCheck(values[selection[i]]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable[] values, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValueWithNullCheck(values[i]); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable value, + int batchSize, + int[] selection, + boolean[] isNull) { + + if (isNull[0]) { + return; + } + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValueWithNullCheck(value); + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable value, + int batchSize, + boolean[] isNull) { + + if (isNull[0]) { + return; + } + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValueWithNullCheck(value); + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable[] values, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int j=0; j < batchSize; ++j) { + int i = selection[j]; + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + j); + myagg.sumValueWithNullCheck(values[i]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + HiveDecimalWritable[] values, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValueWithNullCheck(values[i]); + } + } + } + + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + DecimalColumnVector inputVector = + (DecimalColumnVector)batch.cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + HiveDecimalWritable[] vector = inputVector.vector; + + if (inputVector.isRepeating) { + if (inputVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum.setFromLong(0L); + myagg.count = 0; + } + HiveDecimal value = vector[0].getHiveDecimal(); + HiveDecimal multiple = value.multiply(HiveDecimal.create(batchSize)); + myagg.sum.mutateAdd(multiple); + myagg.count += batchSize; + } + return; + } + + if (!batch.selectedInUse && inputVector.noNulls) { + iterateNoSelectionNoNulls(myagg, vector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); + } + else if (inputVector.noNulls){ + iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + HiveDecimalWritable[] vector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + myagg.sumValueWithNullCheck(vector[i]); + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + HiveDecimalWritable[] vector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum.setFromLong(0L); + myagg.count = 0; + } + + for (int i=0; i< batchSize; ++i) { + myagg.sumValueNoNullCheck(vector[selected[i]]); + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + HiveDecimalWritable[] vector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** class for storing the current aggregate value. */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private final HiveDecimalWritable mergeSum = new HiveDecimalWritable(); + transient private long mergeCount; + transient private boolean isNull; + + public void mergeWithNullCheck(long count, HiveDecimalWritable sum) { + if (isNull) { + // Make a copy since we intend to mutate sum. + mergeCount = count; + mergeSum.set(sum); + isNull = false; + } else { + // Note that if sum is out of range, mutateAdd will ignore the call. + // At the end, sum.isSet() can be checked for null. + mergeCount += count; + mergeSum.mutateAdd(sum); + } + } + + public void mergeNoNullCheck(long count, HiveDecimalWritable sum) { + mergeCount += count; + mergeSum.mutateAdd(sum); + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + + @Override + public void reset() { + isNull = true; + mergeCount = 0; + mergeSum.setFromLong(0L); + } + } + + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; + + @Override + public VectorExpression inputExpression() { + return inputExpression; + } + +#IF PARTIAL2 + transient private Object[] partialResult; + transient private LongWritable resultCount; + transient private HiveDecimalWritable resultSum; + transient private StructObjectInspector soi; +#ENDIF PARTIAL2 +#IF FINAL + transient private HiveDecimalWritable tempDecWritable; + transient private HiveDecimalWritable fullResult; + transient private ObjectInspector oi; +#ENDIF FINAL + + /** + * The scale of the SUM in the partial output + */ + private int sumScale; + + /** + * The precision of the SUM in the partial output + */ + private int sumPrecision; + + /** + * the scale of the input expression + */ + private int inputScale; + + /** + * the precision of the input expression + */ + private int inputPrecision; + + public (VectorExpression inputExpression, + GenericUDAFEvaluator.Mode mode) { + this(); + this.inputExpression = inputExpression; + this.mode = mode; +#IF PARTIAL2 + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.PARTIAL2); +#ENDIF PARTIAL2 +#IF FINAL + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.FINAL); +#ENDIF FINAL + } + + public () { + super(); +#IF PARTIAL2 + partialResult = new Object[2]; + resultCount = new LongWritable(); + resultSum = new HiveDecimalWritable(); + partialResult[0] = resultCount; + partialResult[1] = resultSum; +#ENDIF PARTIAL2 +#IF FINAL + tempDecWritable = new HiveDecimalWritable(); + fullResult = new HiveDecimalWritable(); +#ENDIF FINAL + } + +#IF PARTIAL2 + private void initPartialResultInspector() { +#ENDIF PARTIAL2 +#IF FINAL + private void initFullResultInspector() { +#ENDIF FINAL + // the output type of the vectorized partial aggregate must match the + // expected type for the row-mode aggregation + // For decimal, the type is "same number of integer digits and 4 more decimal digits" + + DecimalTypeInfo decTypeInfo = + GenericUDAFAverageEvaluatorDecimal.deriveResultDecimalTypeInfo( + inputPrecision, inputScale, mode); + this.sumScale = decTypeInfo.scale(); + this.sumPrecision = decTypeInfo.precision(); + +#IF PARTIAL2 + List foi = new ArrayList(); + foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(decTypeInfo)); + List fname = new ArrayList(); + fname.add("count"); + fname.add("sum"); + soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); +#ENDIF PARTIAL2 +#IF FINAL + oi = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(decTypeInfo); +#ENDIF FINAL + } + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + StructColumnVector inputStructColVector = + (StructColumnVector) batch.cols[this.inputExpression.getOutputColumn()]; + ColumnVector[] fields = inputStructColVector.fields; + + long[] countVector = ((LongColumnVector) fields[COUNT_OFFSET]).vector; + HiveDecimalWritable[] sumVector = ((DecimalColumnVector) fields[SUM_OFFSET]).vector; + + if (inputStructColVector.noNulls) { + if (inputStructColVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector[0], sumVector[0], batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batchSize); + } + } + } else { + if (inputStructColVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector[0], sumVector[0], batchSize, batch.selected, inputStructColVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector[0], sumVector[0], batchSize, inputStructColVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batchSize, batch.selected, inputStructColVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batchSize, inputStructColVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long count, + HiveDecimalWritable sum, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.mergeWithNullCheck(count, sum); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + HiveDecimalWritable[] sumVector, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + final int batchIndex = selection[i]; + myagg.mergeWithNullCheck(countVector[batchIndex], sumVector[batchIndex]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.mergeWithNullCheck(countVector[i], sumVector[i]); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long count, + HiveDecimalWritable sum, + int batchSize, + int[] selection, + boolean[] isNull) { + + if (isNull[0]) { + return; + } + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.mergeWithNullCheck(count, sum); + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long count, + HiveDecimalWritable sum, + int batchSize, + boolean[] isNull) { + + if (isNull[0]) { + return; + } + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.mergeWithNullCheck(count, sum); + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int i = 0; i < batchSize; i++) { + final int batchIndex = selection[i]; + if (!isNull[batchIndex]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.mergeWithNullCheck(countVector[batchIndex], sumVector[batchIndex]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.mergeWithNullCheck(countVector[i], sumVector[i]); + } + } + } + + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + StructColumnVector inputStructColVector = + (StructColumnVector) batch.cols[this.inputExpression.getOutputColumn()]; + ColumnVector[] fields = inputStructColVector.fields; + + long[] countVector = ((LongColumnVector) fields[COUNT_OFFSET]).vector; + HiveDecimalWritable[] sumVector = ((DecimalColumnVector) fields[SUM_OFFSET]).vector; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + if (inputStructColVector.isRepeating) { + if (inputStructColVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeSum.setFromLong(0L); + myagg.mergeCount = 0; + } + myagg.mergeCount += countVector[0] * batchSize; + HiveDecimal sum = sumVector[0].getHiveDecimal(); + HiveDecimal multiple = sum.multiply(HiveDecimal.create(batchSize)); + myagg.mergeSum.mutateAdd(multiple); + } + return; + } + + if (!batch.selectedInUse && inputStructColVector.noNulls) { + iterateNoSelectionNoNulls(myagg, countVector, sumVector, batchSize); + } else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, countVector, sumVector, batchSize, inputStructColVector.isNull); + } else if (inputStructColVector.noNulls){ + iterateSelectionNoNulls(myagg, countVector, sumVector, batchSize, batch.selected); + } else { + iterateSelectionHasNulls(myagg, countVector, sumVector, batchSize, inputStructColVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int i = 0; i < batchSize; i++) { + final int batchIndex = selected[i]; + if (!isNull[batchIndex]) { + myagg.mergeWithNullCheck(countVector[batchIndex], sumVector[batchIndex]); + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeSum.setFromLong(0L); + myagg.mergeCount = 0; + } + + for (int i = 0; i< batchSize; i++) { + final int batchIndex = selected[i]; + myagg.mergeNoNullCheck(countVector[batchIndex], sumVector[batchIndex]); + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize, + boolean[] isNull) { + + for(int i = 0; i < batchSize; i++) { + if (!isNull[i]) { + myagg.mergeWithNullCheck(countVector[i], sumVector[i]); + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + long[] countVector, + HiveDecimalWritable[] sumVector, + int batchSize) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeSum.setFromLong(0L); + myagg.mergeCount = 0; + } + + for (int i = 0; i < batchSize; i++) { + myagg.mergeNoNullCheck(countVector[i], sumVector[i]); + } + } + + @Override + public AggregationBuffer getNewAggregationBuffer() throws HiveException { + return new Aggregation(); + } + + @Override + public void reset(AggregationBuffer agg) throws HiveException { + Aggregation myAgg = (Aggregation) agg; + myAgg.reset(); + } + + @Override + public Object evaluateOutput( + AggregationBuffer agg) throws HiveException { + Aggregation myagg = (Aggregation) agg; + // !isSet checks for overflow. + if (myagg.isNull || !myagg.mergeSum.isSet()) { + return null; + } + else { + assert(0 < myagg.mergeCount); +#IF PARTIAL2 + resultCount.set (myagg.mergeCount); + resultSum.set(myagg.mergeSum); + return partialResult; +#ENDIF PARTIAL2 +#IF FINAL + tempDecWritable.setFromLong (myagg.mergeCount); + fullResult.set(myagg.mergeSum); + fullResult.mutateDivide(tempDecWritable); + fullResult.mutateEnforcePrecisionScale(sumPrecision, sumScale); + return fullResult; +#ENDIF FINAL + } + } + + @Override + public ObjectInspector getOutputObjectInspector() { +#IF PARTIAL2 + return soi; +#ENDIF PARTIAL2 +#IF FINAL + return oi; +#ENDIF FINAL + } + + @Override + public int getAggregationBufferFixedSize() { + JavaDataModel model = JavaDataModel.get(); + return JavaDataModel.alignUp( + model.object() + + model.primitive2() * 2, + model.memoryAlign()); + } + + @Override + public void init(AggregationDesc desc) throws HiveException { + ExprNodeDesc inputExpr = desc.getParameters().get(0); + DecimalTypeInfo tiInput = (DecimalTypeInfo) inputExpr.getTypeInfo(); + this.inputScale = tiInput.scale(); + this.inputPrecision = tiInput.precision(); + +#IF PARTIAL2 + initPartialResultInspector(); +#ENDIF PARTIAL2 +#IF FINAL + initFullResultInspector(); +#ENDIF FINAL + } + + public VectorExpression getInputExpression() { + return inputExpression; + } + + public void setInputExpression(VectorExpression inputExpression) { + this.inputExpression = inputExpression; + } +} + diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvgMerge.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvgMerge.txt new file mode 100644 index 0000000..ad72b03 --- /dev/null +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFAvgMerge.txt @@ -0,0 +1,568 @@ +/** + * 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.exec.vector.expressions.aggregates.gen; + +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.hive.ql.exec.Description; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; +import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; +import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; +import org.apache.hadoop.hive.ql.exec.vector.ColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.StructColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; +import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; +import org.apache.hadoop.hive.ql.metadata.HiveException; +import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; +import org.apache.hadoop.hive.ql.util.JavaDataModel; +import org.apache.hadoop.io.LongWritable; +import org.apache.hadoop.hive.serde2.io.DoubleWritable; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; +import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; +import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; +#IF TIMESTAMP +import org.apache.hadoop.hive.serde2.io.TimestampWritable; +import org.apache.hadoop.hive.ql.util.TimestampUtils; +#ENDIF TIMESTAMP + +import com.google.common.base.Preconditions; + +/** + * Generated from template VectorUDAFAvg.txt. + */ +@Description(name = "avg", + value = "_FUNC_(expr) - Returns the average value of expr (vectorized, type: )") +public class extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** class for storing the current aggregate value. */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private double mergeSum; + transient private long mergeCount; + + /** + * Value is explicitly (re)initialized in reset() + */ + transient private boolean isNull = true; + + public void merge(long count, double sum) { + if (isNull) { + mergeCount = count; + mergeSum = sum; + isNull = false; + } else { + mergeCount += count; + mergeSum += sum; + } + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + + @Override + public void reset () { + isNull = true; + mergeCount = 0L; + mergeSum = 0; + } + } + + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; + + @Override + public VectorExpression inputExpression() { + return inputExpression; + } + +#IF PARTIAL2 + transient private Object[] partialResult; + transient private LongWritable resultCount; + transient private DoubleWritable resultSum; + transient private StructObjectInspector soi; +#ENDIF PARTIAL2 +#IF FINAL +#IF TIMESTAMP + transient private TimestampWritable fullResult; +#ELSE + transient private DoubleWritable fullResult; +#ENDIF TIMESTAMP + transient private ObjectInspector oi; +#ENDIF FINAL + + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { + this(); + this.inputExpression = inputExpression; + this.mode = mode; +#IF PARTIAL2 + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.PARTIAL2); +#ENDIF PARTIAL2 +#IF FINAL + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.FINAL); +#ENDIF FINAL + } + + public () { + super(); +#IF PARTIAL2 + partialResult = new Object[2]; + resultCount = new LongWritable(); + resultSum = new DoubleWritable(); + partialResult[0] = resultCount; + partialResult[1] = resultSum; + initPartialResultInspector(); +#ENDIF PARTIAL2 +#IF FINAL +#IF TIMESTAMP + fullResult = new TimestampWritable(); +#ELSE + fullResult = new DoubleWritable(); +#ENDIF TIMESTAMP + initFullResultInspector(); +#ENDIF FINAL + } + +#IF PARTIAL2 + private void initPartialResultInspector() { + List foi = new ArrayList(); + foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); + List fname = new ArrayList(); + fname.add("count"); + fname.add("sum"); + soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); + } +#ENDIF PARTIAL2 +#IF FINAL + private void initFullResultInspector() { +#IF TIMESTAMP + oi = PrimitiveObjectInspectorFactory.writableTimestampObjectInspector; +#ELSE + oi = PrimitiveObjectInspectorFactory.writableDoubleObjectInspector; +#ENDIF TIMESTAMP + } +#ENDIF FINAL + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + StructColumnVector inputStructColVector = + (StructColumnVector) batch.cols[this.inputExpression.getOutputColumn()]; + ColumnVector[] fields = inputStructColVector.fields; + + long[] countVector = ((LongColumnVector) fields[COUNT_OFFSET]).vector; + double[] sumVector = ((DoubleColumnVector) fields[SUM_OFFSET]).vector; + + if (inputStructColVector.noNulls) { + if (inputStructColVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector[0], sumVector[0], batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batchSize); + } + } + } else { + if (inputStructColVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector[0], sumVector[0], batchSize, batch.selected, inputStructColVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector[0], sumVector[0], batchSize, inputStructColVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batchSize, batch.selected, inputStructColVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + countVector, sumVector, batchSize, inputStructColVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long count, + double sum, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.merge(count, sum); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + double[] sumVector, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + final int batchIndex = selection[i]; + myagg.merge(countVector[batchIndex], sumVector[batchIndex]); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + double[] sumVector, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.merge(countVector[i], sumVector[i]); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long count, + double sum, + int batchSize, + int[] selection, + boolean[] isNull) { + + if (isNull[0]) { + return; + } + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.merge(count, sum); + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long count, + double sum, + int batchSize, + boolean[] isNull) { + + if (isNull[0]) { + return; + } + + for (int i = 0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.merge(count, sum); + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + double[] sumVector, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int i = 0; i < batchSize; i++) { + final int batchIndex = selection[i]; + if (!isNull[batchIndex]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.merge(countVector[batchIndex], sumVector[batchIndex]); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + long[] countVector, + double[] sumVector, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.merge(countVector[i], sumVector[i]); + } + } + } + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + StructColumnVector inputStructColVector = + (StructColumnVector) batch.cols[this.inputExpression.getOutputColumn()]; + ColumnVector[] fields = inputStructColVector.fields; + + long[] countVector = ((LongColumnVector) fields[COUNT_OFFSET]).vector; + double[] sumVector = ((DoubleColumnVector) fields[SUM_OFFSET]).vector; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + if (inputStructColVector.isRepeating) { + if (inputStructColVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeCount = 0; + myagg.mergeSum = 0; + } + myagg.mergeCount += countVector[0] * batchSize; + myagg.mergeSum += sumVector[0] * batchSize; + } + return; + } + + if (!batch.selectedInUse && inputStructColVector.noNulls) { + iterateNoSelectionNoNulls(myagg, countVector, sumVector, batchSize); + } else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, countVector, sumVector, batchSize, inputStructColVector.isNull); + } else if (inputStructColVector.noNulls){ + iterateSelectionNoNulls(myagg, countVector, sumVector, batchSize, batch.selected); + } else { + iterateSelectionHasNulls(myagg, countVector, sumVector, batchSize, inputStructColVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + long[] countVector, + double[] sumVector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int i=0; i < batchSize; i++) { + int batchIndex = selected[i]; + if (!isNull[batchIndex]) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeCount = 0; + myagg.mergeSum = 0; + } + myagg.mergeCount += countVector[batchIndex]; + myagg.mergeSum += sumVector[batchIndex]; + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + long[] countVector, + double[] sumVector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeCount = 0; + myagg.mergeSum = 0; + } + + for (int i = 0; i< batchSize; ++i) { + final int batchIndex = selected[i]; + myagg.mergeCount += countVector[batchIndex]; + myagg.mergeSum += sumVector[batchIndex]; + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + long[] countVector, + double[] sumVector, + int batchSize, + boolean[] isNull) { + + for(int i = 0; i < batchSize; i++) { + if (!isNull[i]) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeCount = 0; + myagg.mergeSum = 0; + } + myagg.mergeCount += countVector[i]; + myagg.mergeSum += sumVector[i]; + } + } + } + + private void iterateNoSelectionNoNulls( + Aggregation myagg, + long[] countVector, + double[] sumVector, + int batchSize) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.mergeCount = 0; + myagg.mergeSum = 0; + } + + for (int i=0;i extends VectorAggregateExpression { + + private static final long serialVersionUID = 1L; + + /** class for storing the current aggregate value. */ + static class Aggregation implements AggregationBuffer { + + private static final long serialVersionUID = 1L; + + transient private double sum; + transient private long count; + + /** + * Value is explicitly (re)initialized in reset() + */ + transient private boolean isNull = true; + + public void sumValue(double value) { + if (isNull) { + sum = value; + count = 1; + isNull = false; + } else { + sum += value; + count++; + } + } + + @Override + public int getVariableSize() { + throw new UnsupportedOperationException(); + } + + @Override + public void reset() { + isNull = true; + sum = 0; + count = 0L; + } + } + + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; + + @Override + public VectorExpression inputExpression() { + return inputExpression; + } + +#IF PARTIAL1 + transient private Object[] partialResult; + transient private LongWritable resultCount; + transient private DoubleWritable resultSum; + transient private StructObjectInspector soi; +#ENDIF PARTIAL1 +#IF COMPLETE + transient private TimestampWritable fullResult; + transient private ObjectInspector oi; +#ENDIF COMPLETE + + public (VectorExpression inputExpression, + GenericUDAFEvaluator.Mode mode) { + this(); + this.inputExpression = inputExpression; + this.mode = mode; +#IF PARTIAL1 + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.PARTIAL1); +#ENDIF PARTIAL1 +#IF COMPLETE + Preconditions.checkState(this.mode == GenericUDAFEvaluator.Mode.COMPLETE); +#ENDIF COMPLETE + } + + public () { + super(); +#IF PARTIAL1 + partialResult = new Object[2]; + resultCount = new LongWritable(); + resultSum = new DoubleWritable(); + partialResult[0] = resultCount; + partialResult[1] = resultSum; + initPartialResultInspector(); +#ENDIF PARTIAL1 +#IF COMPLETE + fullResult = new TimestampWritable(); +#ENDIF COMPLETE + } + +#IF PARTIAL1 + private void initPartialResultInspector() { + List foi = new ArrayList(); + foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); + foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); + List fname = new ArrayList(); + fname.add("count"); + fname.add("sum"); + soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); + } +#ENDIF PARTIAL1 +#IF COMPLETE + private void initFullResultInspector() { + oi = PrimitiveObjectInspectorFactory.writableTimestampObjectInspector; + } +#ENDIF COMPLETE + + private Aggregation getCurrentAggregationBuffer( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + int row) { + VectorAggregationBufferRow mySet = aggregationBufferSets[row]; + Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); + return myagg; + } + + @Override + public void aggregateInputSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + VectorizedRowBatch batch) throws HiveException { + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + inputExpression.evaluate(batch); + + TimestampColumnVector inputColVector = (TimestampColumnVector)batch. + cols[this.inputExpression.getOutputColumn()]; + + if (inputColVector.noNulls) { + if (inputColVector.isRepeating) { + iterateNoNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector.getDouble(0), + batchSize); + } else { + if (batch.selectedInUse) { + iterateNoNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector, batch.selected, batchSize); + } else { + iterateNoNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector, batchSize); + } + } + } else { + if (inputColVector.isRepeating) { + if (batch.selectedInUse) { + iterateHasNullsRepeatingSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector.getDouble(0), batchSize, batch.selected, inputColVector.isNull); + } else { + iterateHasNullsRepeatingWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector.getDouble(0), batchSize, inputColVector.isNull); + } + } else { + if (batch.selectedInUse) { + iterateHasNullsSelectionWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector, batchSize, batch.selected, inputColVector.isNull); + } else { + iterateHasNullsWithAggregationSelection( + aggregationBufferSets, bufferIndex, + inputColVector, batchSize, inputColVector.isNull); + } + } + } + } + + private void iterateNoNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + double value, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(value); + } + } + + private void iterateNoNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + TimestampColumnVector inputColVector, + int[] selection, + int batchSize) { + + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue( + inputColVector.getDouble(selection[i])); + } + } + + private void iterateNoNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + TimestampColumnVector inputColVector, + int batchSize) { + for (int i=0; i < batchSize; ++i) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(inputColVector.getDouble(i)); + } + } + + private void iterateHasNullsRepeatingSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + double value, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[selection[i]]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(value); + } + } + + } + + private void iterateHasNullsRepeatingWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + double value, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(value); + } + } + } + + private void iterateHasNullsSelectionWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + TimestampColumnVector inputColVector, + int batchSize, + int[] selection, + boolean[] isNull) { + + for (int j=0; j < batchSize; ++j) { + int i = selection[j]; + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + j); + myagg.sumValue(inputColVector.getDouble(i)); + } + } + } + + private void iterateHasNullsWithAggregationSelection( + VectorAggregationBufferRow[] aggregationBufferSets, + int bufferIndex, + TimestampColumnVector inputColVector, + int batchSize, + boolean[] isNull) { + + for (int i=0; i < batchSize; ++i) { + if (!isNull[i]) { + Aggregation myagg = getCurrentAggregationBuffer( + aggregationBufferSets, + bufferIndex, + i); + myagg.sumValue(inputColVector.getDouble(i)); + } + } + } + + @Override + public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) + throws HiveException { + + inputExpression.evaluate(batch); + + TimestampColumnVector inputColVector = + (TimestampColumnVector)batch.cols[this.inputExpression.getOutputColumn()]; + + int batchSize = batch.size; + + if (batchSize == 0) { + return; + } + + Aggregation myagg = (Aggregation)agg; + + if (inputColVector.isRepeating) { + if (inputColVector.noNulls) { + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + myagg.sum += inputColVector.getDouble(0)*batchSize; + myagg.count += batchSize; + } + return; + } + + if (!batch.selectedInUse && inputColVector.noNulls) { + iterateNoSelectionNoNulls(myagg, inputColVector, batchSize); + } + else if (!batch.selectedInUse) { + iterateNoSelectionHasNulls(myagg, inputColVector, batchSize, inputColVector.isNull); + } + else if (inputColVector.noNulls){ + iterateSelectionNoNulls(myagg, inputColVector, batchSize, batch.selected); + } + else { + iterateSelectionHasNulls(myagg, inputColVector, batchSize, inputColVector.isNull, batch.selected); + } + } + + private void iterateSelectionHasNulls( + Aggregation myagg, + TimestampColumnVector inputColVector, + int batchSize, + boolean[] isNull, + int[] selected) { + + for (int j=0; j< batchSize; ++j) { + int i = selected[j]; + if (!isNull[i]) { + double value = inputColVector.getDouble(i); + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + myagg.sum += value; + myagg.count += 1; + } + } + } + + private void iterateSelectionNoNulls( + Aggregation myagg, + TimestampColumnVector inputColVector, + int batchSize, + int[] selected) { + + if (myagg.isNull) { + myagg.isNull = false; + myagg.sum = 0; + myagg.count = 0; + } + + for (int i=0; i< batchSize; ++i) { + double value = inputColVector.getDouble(selected[i]); + myagg.sum += value; + myagg.count += 1; + } + } + + private void iterateNoSelectionHasNulls( + Aggregation myagg, + TimestampColumnVector inputColVector, + int batchSize, + boolean[] isNull) { + + for(int i=0;i. Vectorized implementation for MIN/MAX aggregates. +* . Vectorized implementation for MIN/MAX aggregates. */ @Description(name = "", value = "") @@ -75,8 +76,9 @@ public class extends VectorAggregateExpression { value = 0; } } - + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -84,10 +86,11 @@ public class extends VectorAggregateExpression { } private transient VectorExpressionWriter resultWriter; - - public (VectorExpression inputExpression) { + + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt index 57b7ea5..89e11da 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt @@ -29,6 +29,7 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; @@ -82,6 +83,7 @@ public class extends VectorAggregateExpression { } private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -90,9 +92,10 @@ public class extends VectorAggregateExpression { private transient VectorExpressionWriter resultWriter; - public (VectorExpression inputExpression) { + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxIntervalDayTime.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxIntervalDayTime.txt index 749e97e..cf56400 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxIntervalDayTime.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxIntervalDayTime.txt @@ -28,6 +28,7 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.exec.vector.IntervalDayTimeColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; @@ -81,6 +82,7 @@ public class extends VectorAggregateExpression { } private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -89,9 +91,10 @@ public class extends VectorAggregateExpression { private transient VectorExpressionWriter resultWriter; - public (VectorExpression inputExpression) { + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt index 9dfc147..914fd30 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxString.txt @@ -28,6 +28,7 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; @@ -93,6 +94,7 @@ public class extends VectorAggregateExpression { } private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -101,9 +103,10 @@ public class extends VectorAggregateExpression { transient private Text result; - public (VectorExpression inputExpression) { + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxTimestamp.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxTimestamp.txt index 32ecb34..b5b9e5f 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxTimestamp.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxTimestamp.txt @@ -30,6 +30,7 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.hive.serde2.io.TimestampWritable; import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; @@ -83,6 +84,7 @@ public class extends VectorAggregateExpression { } private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -91,9 +93,10 @@ public class extends VectorAggregateExpression { private transient VectorExpressionWriter resultWriter; - public (VectorExpression inputExpression) { + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt index bd0f14d..e42dce3 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFSum.txt @@ -27,6 +27,7 @@ import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.hive.serde2.io.DoubleWritable; @@ -76,8 +77,9 @@ public class extends VectorAggregateExpression { sum = 0;; } } - + private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -85,10 +87,11 @@ public class extends VectorAggregateExpression { } transient private final result; - - public (VectorExpression inputExpression) { + + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt index dc9d4b1..bd4fe34 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVar.txt @@ -30,6 +30,7 @@ import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; import org.apache.hadoop.hive.ql.exec.vector.DoubleColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.hive.serde2.io.DoubleWritable; @@ -84,6 +85,7 @@ public class extends VectorAggregateExpression { } private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -98,9 +100,10 @@ public class extends VectorAggregateExpression { transient private ObjectInspector soi; - public (VectorExpression inputExpression) { + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt index 01062a9..78658f6 100644 --- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt +++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt @@ -31,6 +31,7 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector; import org.apache.hadoop.hive.ql.metadata.HiveException; import org.apache.hadoop.hive.ql.plan.AggregationDesc; +import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFEvaluator; import org.apache.hadoop.hive.ql.util.JavaDataModel; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.hive.serde2.io.DoubleWritable; @@ -111,6 +112,7 @@ public class extends VectorAggregateExpression { } private VectorExpression inputExpression; + private GenericUDAFEvaluator.Mode mode; @Override public VectorExpression inputExpression() { @@ -124,9 +126,10 @@ public class extends VectorAggregateExpression { transient private ObjectInspector soi; - public (VectorExpression inputExpression) { + public (VectorExpression inputExpression, GenericUDAFEvaluator.Mode mode) { this(); this.inputExpression = inputExpression; + this.mode = mode; } public () { diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/SelectOperator.java ql/src/java/org/apache/hadoop/hive/ql/exec/SelectOperator.java index 94af097..d26fa5b 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/SelectOperator.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/SelectOperator.java @@ -29,6 +29,7 @@ import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; import org.apache.hadoop.hive.ql.plan.SelectDesc; import org.apache.hadoop.hive.ql.plan.api.OperatorType; +import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable; /** * Select operator implementation. @@ -86,6 +87,9 @@ public void process(Object row, int tag) throws HiveException { try { for (; i < eval.length; ++i) { output[i] = eval[i].evaluate(row); + if (output[i] instanceof HiveDecimalWritable) { + System.out.println("*DEBUG* SelectOperator HiveDecimalWritable " + (((HiveDecimalWritable) output[i]).toString())); + } } } catch (HiveException e) { throw e; diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java index c3940cb..f380be0 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java @@ -52,8 +52,6 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor.InputExpressionType; import org.apache.hadoop.hive.ql.exec.vector.expressions.*; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; -import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFAvgDecimal; -import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFAvgTimestamp; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFBloomFilter; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFBloomFilterMerge; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFCount; @@ -64,8 +62,19 @@ import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFSumDecimal; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFVarPopTimestamp; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorUDAFVarSampTimestamp; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDecimal; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDecimalComplete; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDecimalFinal; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDecimalPartial2; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDouble; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgDoubleComplete; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgFinal; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgLong; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgLongComplete; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgPartial2; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgTimestamp; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgTimestampComplete; +import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFAvgTimestampFinal; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMaxDecimal; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMaxDouble; import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.gen.VectorUDAFMaxLong; @@ -2821,11 +2830,28 @@ public static String mapTypeNameSynonyms(String typeName) { // FINAL STRUCT Average Partial Aggregation --> Full Aggregation // COMPLETE Original data --> Full Aggregation // + // NOTE: Since we do average of timestamps internally as double, we do not need a VectorUDAFAvgTimestampPartial2. + // add(new AggregateDefinition("avg", ArgumentType.INT_FAMILY, Mode.PARTIAL1, VectorUDAFAvgLong.class)); add(new AggregateDefinition("avg", ArgumentType.FLOAT_FAMILY, Mode.PARTIAL1, VectorUDAFAvgDouble.class)); add(new AggregateDefinition("avg", ArgumentType.DECIMAL, Mode.PARTIAL1, VectorUDAFAvgDecimal.class)); add(new AggregateDefinition("avg", ArgumentType.TIMESTAMP, Mode.PARTIAL1, VectorUDAFAvgTimestamp.class)); + add(new AggregateDefinition("avg", ArgumentType.INT_FAMILY, Mode.PARTIAL2, VectorUDAFAvgPartial2.class)); + add(new AggregateDefinition("avg", ArgumentType.FLOAT_FAMILY, Mode.PARTIAL2, VectorUDAFAvgPartial2.class)); + add(new AggregateDefinition("avg", ArgumentType.DECIMAL, Mode.PARTIAL2, VectorUDAFAvgDecimalPartial2.class)); + add(new AggregateDefinition("avg", ArgumentType.TIMESTAMP, Mode.PARTIAL2, VectorUDAFAvgPartial2.class)); + + add(new AggregateDefinition("avg", ArgumentType.INT_FAMILY, Mode.FINAL, VectorUDAFAvgFinal.class)); + add(new AggregateDefinition("avg", ArgumentType.FLOAT_FAMILY, Mode.FINAL, VectorUDAFAvgFinal.class)); + add(new AggregateDefinition("avg", ArgumentType.DECIMAL, Mode.FINAL, VectorUDAFAvgDecimalFinal.class)); + add(new AggregateDefinition("avg", ArgumentType.TIMESTAMP, Mode.FINAL, VectorUDAFAvgTimestampFinal.class)); + + add(new AggregateDefinition("avg", ArgumentType.INT_FAMILY, Mode.COMPLETE, VectorUDAFAvgLongComplete.class)); + add(new AggregateDefinition("avg", ArgumentType.FLOAT_FAMILY, Mode.COMPLETE, VectorUDAFAvgDoubleComplete.class)); + add(new AggregateDefinition("avg", ArgumentType.DECIMAL, Mode.COMPLETE, VectorUDAFAvgDecimalComplete.class)); + add(new AggregateDefinition("avg", ArgumentType.TIMESTAMP, Mode.COMPLETE, VectorUDAFAvgTimestampComplete.class)); + // We haven't had a chance to examine the VAR* and STD* area and expand it beyond PARTIAL1. add(new AggregateDefinition("variance", ArgumentType.INT_FAMILY, Mode.PARTIAL1, VectorUDAFVarPopLong.class)); add(new AggregateDefinition("var_pop", ArgumentType.INT_FAMILY, Mode.PARTIAL1, VectorUDAFVarPopLong.class)); @@ -2904,9 +2930,9 @@ public VectorAggregateExpression getAggregatorExpression(AggregationDesc desc) try { Constructor ctor = - aggClass.getConstructor(VectorExpression.class); + aggClass.getConstructor(VectorExpression.class, GenericUDAFEvaluator.Mode.class); VectorAggregateExpression aggExpr = ctor.newInstance( - vectorParams.length > 0 ? vectorParams[0] : null); + vectorParams.length > 0 ? vectorParams[0] : null, udafEvaluatorMode); aggExpr.init(desc); return aggExpr; } catch (Exception e) { diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java index 0866f63..8eaab32 100644 --- ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java +++ ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorAggregateExpression.java @@ -34,6 +34,10 @@ private static final long serialVersionUID = 1L; + public static final int COUNT_OFFSET = 0; + public static final int SUM_OFFSET = 1; + public static final int VARIANCE_OFFSET = 2; + /** * Buffer interface to store aggregates. */ diff --git ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFAvgDecimal.java ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFAvgDecimal.java deleted file mode 100644 index 74e25ae..0000000 --- ql/src/java/org/apache/hadoop/hive/ql/exec/vector/expressions/aggregates/VectorUDAFAvgDecimal.java +++ /dev/null @@ -1,521 +0,0 @@ -/** - * 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.exec.vector.expressions.aggregates; - -import java.util.ArrayList; -import java.util.List; - -import org.apache.hadoop.hive.common.type.HiveDecimal; -import org.apache.hadoop.hive.ql.exec.Description; -import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil; -import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; -import org.apache.hadoop.hive.ql.exec.vector.expressions.aggregates.VectorAggregateExpression; -import org.apache.hadoop.hive.ql.exec.vector.VectorAggregationBufferRow; -import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; -import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector; -import org.apache.hadoop.hive.ql.metadata.HiveException; -import org.apache.hadoop.hive.ql.plan.AggregationDesc; -import org.apache.hadoop.hive.ql.plan.ExprNodeDesc; -import org.apache.hadoop.hive.ql.udf.generic.GenericUDAFAverage; -import org.apache.hadoop.hive.ql.util.JavaDataModel; -import org.apache.hadoop.io.LongWritable; -import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable; -import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspector; -import org.apache.hadoop.hive.serde2.objectinspector.ObjectInspectorFactory; -import org.apache.hadoop.hive.serde2.objectinspector.StructObjectInspector; -import org.apache.hadoop.hive.serde2.objectinspector.primitive.PrimitiveObjectInspectorFactory; -import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo; - -/** - * Generated from template VectorUDAFAvg.txt. - */ -@Description(name = "avg", - value = "_FUNC_(AVG) - Returns the average value of expr (vectorized, type: decimal)") -public class VectorUDAFAvgDecimal extends VectorAggregateExpression { - - private static final long serialVersionUID = 1L; - - /** class for storing the current aggregate value. */ - static class Aggregation implements AggregationBuffer { - - private static final long serialVersionUID = 1L; - - transient private final HiveDecimalWritable sum = new HiveDecimalWritable(); - transient private long count; - transient private boolean isNull; - - public void sumValueWithNullCheck(HiveDecimalWritable writable) { - if (isNull) { - // Make a copy since we intend to mutate sum. - sum.set(writable); - count = 1; - isNull = false; - } else { - // Note that if sum is out of range, mutateAdd will ignore the call. - // At the end, sum.isSet() can be checked for null. - sum.mutateAdd(writable); - count++; - } - } - - public void sumValueNoNullCheck(HiveDecimalWritable writable) { - sum.mutateAdd(writable); - count++; - } - - @Override - public int getVariableSize() { - throw new UnsupportedOperationException(); - } - - @Override - public void reset() { - isNull = true; - sum.setFromLong(0L); - count = 0; - } - } - - private VectorExpression inputExpression; - - @Override - public VectorExpression inputExpression() { - return inputExpression; - } - - transient private Object[] partialResult; - transient private LongWritable resultCount; - transient private HiveDecimalWritable resultSum; - transient private StructObjectInspector soi; - - /** - * The scale of the SUM in the partial output - */ - private short sumScale; - - /** - * The precision of the SUM in the partial output - */ - private short sumPrecision; - - /** - * the scale of the input expression - */ - private short inputScale; - - /** - * the precision of the input expression - */ - private short inputPrecision; - - public VectorUDAFAvgDecimal(VectorExpression inputExpression) { - this(); - this.inputExpression = inputExpression; - } - - public VectorUDAFAvgDecimal() { - super(); - partialResult = new Object[2]; - resultCount = new LongWritable(); - resultSum = new HiveDecimalWritable(); - partialResult[0] = resultCount; - partialResult[1] = resultSum; - - } - - private void initPartialResultInspector() { - // the output type of the vectorized partial aggregate must match the - // expected type for the row-mode aggregation - // For decimal, the type is "same number of integer digits and 4 more decimal digits" - - DecimalTypeInfo dtiSum = GenericUDAFAverage.deriveSumFieldTypeInfo(inputPrecision, inputScale); - this.sumScale = (short) dtiSum.scale(); - this.sumPrecision = (short) dtiSum.precision(); - - List foi = new ArrayList(); - foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); - foi.add(PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(dtiSum)); - List fname = new ArrayList(); - fname.add("count"); - fname.add("sum"); - soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); - } - - private Aggregation getCurrentAggregationBuffer( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - int row) { - VectorAggregationBufferRow mySet = aggregationBufferSets[row]; - Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); - return myagg; - } - - @Override - public void aggregateInputSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - VectorizedRowBatch batch) throws HiveException { - - int batchSize = batch.size; - - if (batchSize == 0) { - return; - } - - inputExpression.evaluate(batch); - - DecimalColumnVector inputVector = ( DecimalColumnVector)batch. - cols[this.inputExpression.getOutputColumn()]; - HiveDecimalWritable[] vector = inputVector.vector; - - if (inputVector.noNulls) { - if (inputVector.isRepeating) { - iterateNoNullsRepeatingWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector[0], batchSize); - } else { - if (batch.selectedInUse) { - iterateNoNullsSelectionWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector, batch.selected, batchSize); - } else { - iterateNoNullsWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector, batchSize); - } - } - } else { - if (inputVector.isRepeating) { - if (batch.selectedInUse) { - iterateHasNullsRepeatingSelectionWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector[0], batchSize, batch.selected, inputVector.isNull); - } else { - iterateHasNullsRepeatingWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector[0], batchSize, inputVector.isNull); - } - } else { - if (batch.selectedInUse) { - iterateHasNullsSelectionWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector, batchSize, batch.selected, inputVector.isNull); - } else { - iterateHasNullsWithAggregationSelection( - aggregationBufferSets, bufferIndex, - vector, batchSize, inputVector.isNull); - } - } - } - } - - private void iterateNoNullsRepeatingWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable value, - int batchSize) { - - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValueWithNullCheck(value); - } - } - - private void iterateNoNullsSelectionWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable[] values, - int[] selection, - int batchSize) { - - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValueWithNullCheck(values[selection[i]]); - } - } - - private void iterateNoNullsWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable[] values, - int batchSize) { - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValueWithNullCheck(values[i]); - } - } - - private void iterateHasNullsRepeatingSelectionWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable value, - int batchSize, - int[] selection, - boolean[] isNull) { - - if (isNull[0]) { - return; - } - - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValueWithNullCheck(value); - } - - } - - private void iterateHasNullsRepeatingWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable value, - int batchSize, - boolean[] isNull) { - - if (isNull[0]) { - return; - } - - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValueWithNullCheck(value); - } - } - - private void iterateHasNullsSelectionWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable[] values, - int batchSize, - int[] selection, - boolean[] isNull) { - - for (int j=0; j < batchSize; ++j) { - int i = selection[j]; - if (!isNull[i]) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - j); - myagg.sumValueWithNullCheck(values[i]); - } - } - } - - private void iterateHasNullsWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - HiveDecimalWritable[] values, - int batchSize, - boolean[] isNull) { - - for (int i=0; i < batchSize; ++i) { - if (!isNull[i]) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValueWithNullCheck(values[i]); - } - } - } - - - @Override - public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) - throws HiveException { - - inputExpression.evaluate(batch); - - DecimalColumnVector inputVector = - (DecimalColumnVector)batch.cols[this.inputExpression.getOutputColumn()]; - - int batchSize = batch.size; - - if (batchSize == 0) { - return; - } - - Aggregation myagg = (Aggregation)agg; - - HiveDecimalWritable[] vector = inputVector.vector; - - if (inputVector.isRepeating) { - if (inputVector.noNulls) { - if (myagg.isNull) { - myagg.isNull = false; - myagg.sum.setFromLong(0L); - myagg.count = 0; - } - HiveDecimal value = vector[0].getHiveDecimal(); - HiveDecimal multiple = value.multiply(HiveDecimal.create(batchSize)); - myagg.sum.mutateAdd(multiple); - myagg.count += batchSize; - } - return; - } - - if (!batch.selectedInUse && inputVector.noNulls) { - iterateNoSelectionNoNulls(myagg, vector, batchSize); - } - else if (!batch.selectedInUse) { - iterateNoSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull); - } - else if (inputVector.noNulls){ - iterateSelectionNoNulls(myagg, vector, batchSize, batch.selected); - } - else { - iterateSelectionHasNulls(myagg, vector, batchSize, inputVector.isNull, batch.selected); - } - } - - private void iterateSelectionHasNulls( - Aggregation myagg, - HiveDecimalWritable[] vector, - int batchSize, - boolean[] isNull, - int[] selected) { - - for (int j=0; j< batchSize; ++j) { - int i = selected[j]; - if (!isNull[i]) { - myagg.sumValueWithNullCheck(vector[i]); - } - } - } - - private void iterateSelectionNoNulls( - Aggregation myagg, - HiveDecimalWritable[] vector, - int batchSize, - int[] selected) { - - if (myagg.isNull) { - myagg.isNull = false; - myagg.sum.setFromLong(0L); - myagg.count = 0; - } - - for (int i=0; i< batchSize; ++i) { - myagg.sumValueNoNullCheck(vector[selected[i]]); - } - } - - private void iterateNoSelectionHasNulls( - Aggregation myagg, - HiveDecimalWritable[] vector, - int batchSize, - boolean[] isNull) { - - for(int i=0;i foi = new ArrayList(); - foi.add(PrimitiveObjectInspectorFactory.writableLongObjectInspector); - foi.add(PrimitiveObjectInspectorFactory.writableDoubleObjectInspector); - List fname = new ArrayList(); - fname.add("count"); - fname.add("sum"); - soi = ObjectInspectorFactory.getStandardStructObjectInspector(fname, foi); - } - - private Aggregation getCurrentAggregationBuffer( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - int row) { - VectorAggregationBufferRow mySet = aggregationBufferSets[row]; - Aggregation myagg = (Aggregation) mySet.getAggregationBuffer(bufferIndex); - return myagg; - } - - @Override - public void aggregateInputSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - VectorizedRowBatch batch) throws HiveException { - - int batchSize = batch.size; - - if (batchSize == 0) { - return; - } - - inputExpression.evaluate(batch); - - TimestampColumnVector inputColVector = (TimestampColumnVector)batch. - cols[this.inputExpression.getOutputColumn()]; - - if (inputColVector.noNulls) { - if (inputColVector.isRepeating) { - iterateNoNullsRepeatingWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector.getDouble(0), - batchSize); - } else { - if (batch.selectedInUse) { - iterateNoNullsSelectionWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector, batch.selected, batchSize); - } else { - iterateNoNullsWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector, batchSize); - } - } - } else { - if (inputColVector.isRepeating) { - if (batch.selectedInUse) { - iterateHasNullsRepeatingSelectionWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector.getDouble(0), batchSize, batch.selected, inputColVector.isNull); - } else { - iterateHasNullsRepeatingWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector.getDouble(0), batchSize, inputColVector.isNull); - } - } else { - if (batch.selectedInUse) { - iterateHasNullsSelectionWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector, batchSize, batch.selected, inputColVector.isNull); - } else { - iterateHasNullsWithAggregationSelection( - aggregationBufferSets, bufferIndex, - inputColVector, batchSize, inputColVector.isNull); - } - } - } - } - - private void iterateNoNullsRepeatingWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - double value, - int batchSize) { - - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValue(value); - } - } - - private void iterateNoNullsSelectionWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - TimestampColumnVector inputColVector, - int[] selection, - int batchSize) { - - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValue( - inputColVector.getDouble(selection[i])); - } - } - - private void iterateNoNullsWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - TimestampColumnVector inputColVector, - int batchSize) { - for (int i=0; i < batchSize; ++i) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValue(inputColVector.getDouble(i)); - } - } - - private void iterateHasNullsRepeatingSelectionWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - double value, - int batchSize, - int[] selection, - boolean[] isNull) { - - for (int i=0; i < batchSize; ++i) { - if (!isNull[selection[i]]) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValue(value); - } - } - - } - - private void iterateHasNullsRepeatingWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - double value, - int batchSize, - boolean[] isNull) { - - for (int i=0; i < batchSize; ++i) { - if (!isNull[i]) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValue(value); - } - } - } - - private void iterateHasNullsSelectionWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - TimestampColumnVector inputColVector, - int batchSize, - int[] selection, - boolean[] isNull) { - - for (int j=0; j < batchSize; ++j) { - int i = selection[j]; - if (!isNull[i]) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - j); - myagg.sumValue(inputColVector.getDouble(i)); - } - } - } - - private void iterateHasNullsWithAggregationSelection( - VectorAggregationBufferRow[] aggregationBufferSets, - int bufferIndex, - TimestampColumnVector inputColVector, - int batchSize, - boolean[] isNull) { - - for (int i=0; i < batchSize; ++i) { - if (!isNull[i]) { - Aggregation myagg = getCurrentAggregationBuffer( - aggregationBufferSets, - bufferIndex, - i); - myagg.sumValue(inputColVector.getDouble(i)); - } - } - } - - @Override - public void aggregateInput(AggregationBuffer agg, VectorizedRowBatch batch) - throws HiveException { - - inputExpression.evaluate(batch); - - TimestampColumnVector inputColVector = - (TimestampColumnVector)batch.cols[this.inputExpression.getOutputColumn()]; - - int batchSize = batch.size; - - if (batchSize == 0) { - return; - } - - Aggregation myagg = (Aggregation)agg; - - if (inputColVector.isRepeating) { - if (inputColVector.noNulls) { - if (myagg.isNull) { - myagg.isNull = false; - myagg.sum = 0; - myagg.count = 0; - } - myagg.sum += inputColVector.getDouble(0)*batchSize; - myagg.count += batchSize; - } - return; - } - - if (!batch.selectedInUse && inputColVector.noNulls) { - iterateNoSelectionNoNulls(myagg, inputColVector, batchSize); - } - else if (!batch.selectedInUse) { - iterateNoSelectionHasNulls(myagg, inputColVector, batchSize, inputColVector.isNull); - } - else if (inputColVector.noNulls){ - iterateSelectionNoNulls(myagg, inputColVector, batchSize, batch.selected); - } - else { - iterateSelectionHasNulls(myagg, inputColVector, batchSize, inputColVector.isNull, batch.selected); - } - } - - private void iterateSelectionHasNulls( - Aggregation myagg, - TimestampColumnVector inputColVector, - int batchSize, - boolean[] isNull, - int[] selected) { - - for (int j=0; j< batchSize; ++j) { - int i = selected[j]; - if (!isNull[i]) { - double value = inputColVector.getDouble(i); - if (myagg.isNull) { - myagg.isNull = false; - myagg.sum = 0; - myagg.count = 0; - } - myagg.sum += value; - myagg.count += 1; - } - } - } - - private void iterateSelectionNoNulls( - Aggregation myagg, - TimestampColumnVector inputColVector, - int batchSize, - int[] selected) { - - if (myagg.isNull) { - myagg.isNull = false; - myagg.sum = 0; - myagg.count = 0; - } - - for (int i=0; i< batchSize; ++i) { - double value = inputColVector.getDouble(selected[i]); - myagg.sum += value; - myagg.count += 1; - } - } - - private void iterateNoSelectionHasNulls( - Aggregation myagg, - TimestampColumnVector inputColVector, - int batchSize, - boolean[] isNull) { - - for(int i=0;i getVectorOutputConditionsNotMet() { List results = new ArrayList(); diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFAverage.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFAverage.java index a28f7e8..2ea426c 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFAverage.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFAverage.java @@ -259,16 +259,18 @@ protected ObjectInspector getSumFieldWritableObjectInspector() { } private DecimalTypeInfo deriveResultDecimalTypeInfo() { - int prec = inputOI.precision(); - int scale = inputOI.scale(); + return deriveResultDecimalTypeInfo(inputOI.precision(), inputOI.scale(), mode); + } + + public static DecimalTypeInfo deriveResultDecimalTypeInfo(int precision, int scale, Mode mode) { if (mode == Mode.FINAL || mode == Mode.COMPLETE) { - int intPart = prec - scale; + int intPart = precision - scale; // The avg() result type has the same number of integer digits and 4 more decimal digits. scale = Math.min(scale + 4, HiveDecimal.MAX_SCALE - intPart); return TypeInfoFactory.getDecimalTypeInfo(intPart + scale, scale); } else { // For intermediate sum field - return GenericUDAFAverage.deriveSumFieldTypeInfo(prec, scale); + return GenericUDAFAverage.deriveSumFieldTypeInfo(precision, scale); } } diff --git ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java index 6d3b92b..f4f3a7c 100644 --- ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java +++ ql/src/java/org/apache/hadoop/hive/ql/udf/generic/GenericUDAFSum.java @@ -211,15 +211,15 @@ public ObjectInspector init(Mode m, ObjectInspector[] parameters) throws HiveExc super.init(m, parameters); result = new HiveDecimalWritable(0); inputOI = (PrimitiveObjectInspector) parameters[0]; - // The output precision is 10 greater than the input which should cover at least - // 10b rows. The scale is the same as the input. - DecimalTypeInfo outputTypeInfo = null; + + final DecimalTypeInfo outputTypeInfo; if (mode == Mode.PARTIAL1 || mode == Mode.COMPLETE) { - int precision = Math.min(HiveDecimal.MAX_PRECISION, inputOI.precision() + 10); - outputTypeInfo = TypeInfoFactory.getDecimalTypeInfo(precision, inputOI.scale()); + outputTypeInfo = getOutputDecimalTypeInfoForSum(inputOI.precision(), inputOI.scale(), mode); } else { + // No change. outputTypeInfo = (DecimalTypeInfo) inputOI.getTypeInfo(); } + ObjectInspector oi = PrimitiveObjectInspectorFactory.getPrimitiveWritableObjectInspector(outputTypeInfo); outputOI = (PrimitiveObjectInspector) ObjectInspectorUtils.getStandardObjectInspector( oi, ObjectInspectorCopyOption.JAVA); @@ -227,6 +227,21 @@ public ObjectInspector init(Mode m, ObjectInspector[] parameters) throws HiveExc return oi; } + public static DecimalTypeInfo getOutputDecimalTypeInfoForSum(final int inputPrecision, + int inputScale, Mode mode) { + + // The output precision is 10 greater than the input which should cover at least + // 10b rows. The scale is the same as the input. + DecimalTypeInfo outputTypeInfo = null; + if (mode == Mode.PARTIAL1 || mode == Mode.COMPLETE) { + int precision = Math.min(HiveDecimal.MAX_PRECISION, inputPrecision + 10); + outputTypeInfo = TypeInfoFactory.getDecimalTypeInfo(precision, inputScale); + } else { + outputTypeInfo = TypeInfoFactory.getDecimalTypeInfo(inputPrecision, inputScale); + } + return outputTypeInfo; + } + /** class for storing decimal sum value. */ @AggregationType(estimable = false) // hard to know exactly for decimals static class SumHiveDecimalWritableAgg extends SumAgg { @@ -255,6 +270,8 @@ public void iterate(AggregationBuffer agg, Object[] parameters) throws HiveExcep try { if (isEligibleValue((SumHiveDecimalWritableAgg) agg, parameters[0])) { ((SumHiveDecimalWritableAgg)agg).empty = false; + System.out.println("*DEBUG* iterate Add PrimitiveObjectInspectorUtils.getHiveDecimal(parameters[0], inputOI) " + PrimitiveObjectInspectorUtils.getHiveDecimal(parameters[0], inputOI) + " to " + ((SumHiveDecimalWritableAgg)agg).sum.toString() + + " inputOI.precision " + inputOI.precision() + " scale " + inputOI.scale()); ((SumHiveDecimalWritableAgg)agg).sum.mutateAdd( PrimitiveObjectInspectorUtils.getHiveDecimal(parameters[0], inputOI)); } @@ -282,6 +299,8 @@ public void merge(AggregationBuffer agg, Object partial) throws HiveException { if (isWindowingDistinct()) { throw new HiveException("Distinct windowing UDAF doesn't support merge and terminatePartial"); } else { + System.out.println("*DEBUG* merge Add PrimitiveObjectInspectorUtils.getHiveDecimal(partial, inputOI) " + PrimitiveObjectInspectorUtils.getHiveDecimal(partial, inputOI) + " to " + myagg.sum.toString() + + " inputOI.precision " + inputOI.precision() + " scale " + inputOI.scale()); myagg.sum.mutateAdd(PrimitiveObjectInspectorUtils.getHiveDecimal(partial, inputOI)); } } @@ -294,6 +313,7 @@ public Object terminate(AggregationBuffer agg) throws HiveException { return null; } DecimalTypeInfo decimalTypeInfo = (DecimalTypeInfo)outputOI.getTypeInfo(); + System.out.println("*DEBUG* terminate " + myagg.sum.toString() + " apply enforce precision " + decimalTypeInfo.getPrecision() + " scale " + decimalTypeInfo.getScale()); myagg.sum.mutateEnforcePrecisionScale(decimalTypeInfo.getPrecision(), decimalTypeInfo.getScale()); if (!myagg.sum.isSet()) { LOG.warn("The sum of a column with data type HiveDecimal is out of range"); diff --git ql/src/test/queries/clientpositive/vector_groupby_reduce.q ql/src/test/queries/clientpositive/vector_groupby_reduce.q index f23b26f..8135c33 100644 --- ql/src/test/queries/clientpositive/vector_groupby_reduce.q +++ ql/src/test/queries/clientpositive/vector_groupby_reduce.q @@ -16,18 +16,18 @@ create table store_sales_txt ss_promo_sk int, ss_ticket_number int, ss_quantity int, - ss_wholesale_cost float, - ss_list_price float, - ss_sales_price float, - ss_ext_discount_amt float, - ss_ext_sales_price float, - ss_ext_wholesale_cost float, - ss_ext_list_price float, - ss_ext_tax float, - ss_coupon_amt float, - ss_net_paid float, - ss_net_paid_inc_tax float, - ss_net_profit float + ss_wholesale_cost double, + ss_list_price double, + ss_sales_price double, + ss_ext_discount_amt double, + ss_ext_sales_price double, + ss_ext_wholesale_cost double, + ss_ext_list_price double, + ss_ext_tax double, + ss_coupon_amt double, + ss_net_paid double, + ss_net_paid_inc_tax double, + ss_net_profit double ) row format delimited fields terminated by '|' stored as textfile; @@ -47,18 +47,19 @@ create table store_sales ss_promo_sk int, ss_ticket_number int, ss_quantity int, - ss_wholesale_cost float, - ss_list_price float, - ss_sales_price float, - ss_ext_discount_amt float, - ss_ext_sales_price float, - ss_ext_wholesale_cost float, - ss_ext_list_price float, - ss_ext_tax float, - ss_coupon_amt float, - ss_net_paid float, - ss_net_paid_inc_tax float, - ss_net_profit float + ss_wholesale_cost double, + ss_wholesale_cost_decimal decimal(38,18), + ss_list_price double, + ss_sales_price double, + ss_ext_discount_amt double, + ss_ext_sales_price double, + ss_ext_wholesale_cost double, + ss_ext_list_price double, + ss_ext_tax double, + ss_coupon_amt double, + ss_net_paid double, + ss_net_paid_inc_tax double, + ss_net_profit double ) stored as orc tblproperties ("orc.stripe.size"="33554432", "orc.compress.size"="16384"); @@ -79,6 +80,7 @@ ss_sold_date_sk , ss_ticket_number , ss_quantity , ss_wholesale_cost , + cast(ss_wholesale_cost as decimal(38,18)), ss_list_price , ss_sales_price , ss_ext_discount_amt , @@ -138,23 +140,25 @@ order by m; explain vectorization expression select - ss_ticket_number, sum(ss_item_sk), sum(q) + ss_ticket_number, sum(ss_item_sk), sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales + where ss_ticket_number = 1 group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number order by ss_ticket_number; select - ss_ticket_number, sum(ss_item_sk), sum(q) + ss_ticket_number, sum(ss_item_sk), sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales + where ss_ticket_number = 1 group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number order by ss_ticket_number; @@ -162,10 +166,10 @@ order by ss_ticket_number; explain vectorization expression select - ss_ticket_number, ss_item_sk, sum(q) + ss_ticket_number, ss_item_sk, sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales group by ss_ticket_number, ss_item_sk) a @@ -173,13 +177,12 @@ group by ss_ticket_number, ss_item_sk order by ss_ticket_number, ss_item_sk; select - ss_ticket_number, ss_item_sk, sum(q) + ss_ticket_number, ss_item_sk, sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number, ss_item_sk -order by ss_ticket_number, ss_item_sk; - +order by ss_ticket_number, ss_item_sk; \ No newline at end of file diff --git ql/src/test/results/clientpositive/llap/vector_adaptor_usage_mode.q.out ql/src/test/results/clientpositive/llap/vector_adaptor_usage_mode.q.out index 5b17144..1eb6fa7 100644 --- ql/src/test/results/clientpositive/llap/vector_adaptor_usage_mode.q.out +++ ql/src/test/results/clientpositive/llap/vector_adaptor_usage_mode.q.out @@ -1004,9 +1004,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: string) mode: mergepartial @@ -1086,9 +1088,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: string) mode: hash @@ -1129,9 +1133,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_aggregate_9.q.out ql/src/test/results/clientpositive/llap/vector_aggregate_9.q.out index 8a23d6a..eff7af2 100644 --- ql/src/test/results/clientpositive/llap/vector_aggregate_9.q.out +++ ql/src/test/results/clientpositive/llap/vector_aggregate_9.q.out @@ -144,8 +144,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinDecimal(col 6) -> decimal(38,18), VectorUDAFMaxDecimal(col 6) -> decimal(38,18), VectorUDAFSumDecimal(col 6) -> decimal(38,18), VectorUDAFAvgDecimal(col 6) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgDecimal(col 6) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash diff --git ql/src/test/results/clientpositive/llap/vector_auto_smb_mapjoin_14.q.out ql/src/test/results/clientpositive/llap/vector_auto_smb_mapjoin_14.q.out index a0ac248..209b04b 100644 --- ql/src/test/results/clientpositive/llap/vector_auto_smb_mapjoin_14.q.out +++ ql/src/test/results/clientpositive/llap/vector_auto_smb_mapjoin_14.q.out @@ -97,8 +97,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -123,8 +125,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -231,8 +235,10 @@ STAGE PLANS: Statistics: Num rows: 11 Data size: 1023 Basic stats: COMPLETE Column stats: NONE Group By Operator Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null keys: _col0 (type: int) mode: hash @@ -257,9 +263,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -276,8 +284,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -305,8 +315,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -439,8 +451,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null keys: _col0 (type: int) mode: hash @@ -487,8 +501,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null keys: _col0 (type: int) mode: hash @@ -516,9 +532,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: int) mode: mergepartial @@ -571,9 +589,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: int) mode: mergepartial @@ -703,8 +723,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -729,8 +751,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -844,8 +868,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -870,8 +896,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1009,8 +1037,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1035,8 +1065,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1162,8 +1194,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1188,8 +1222,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1360,8 +1396,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1385,8 +1423,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1486,8 +1526,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1512,8 +1554,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1632,8 +1676,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1658,8 +1704,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1781,8 +1829,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1807,8 +1857,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -2175,8 +2227,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null keys: _col0 (type: int) mode: hash @@ -2204,9 +2258,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: int) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_between_in.q.out ql/src/test/results/clientpositive/llap/vector_between_in.q.out index 9b58d47..a6fe032 100644 --- ql/src/test/results/clientpositive/llap/vector_between_in.q.out +++ ql/src/test/results/clientpositive/llap/vector_between_in.q.out @@ -154,8 +154,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -193,8 +195,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -358,8 +362,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -397,8 +403,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -754,8 +762,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -793,8 +803,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1104,9 +1116,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 5:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 4 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: boolean) mode: hash @@ -1147,9 +1161,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: boolean) mode: mergepartial @@ -1242,9 +1258,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 5:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 4 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: boolean) mode: hash @@ -1285,9 +1303,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: boolean) mode: mergepartial @@ -1380,9 +1400,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 5:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 4 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: boolean) mode: hash @@ -1423,9 +1445,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: boolean) mode: mergepartial @@ -1518,9 +1542,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 5:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 4 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: boolean) mode: hash @@ -1561,9 +1587,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: boolean) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_binary_join_groupby.q.out ql/src/test/results/clientpositive/llap/vector_binary_join_groupby.q.out index 339ec2c..08b3bc2 100644 --- ql/src/test/results/clientpositive/llap/vector_binary_join_groupby.q.out +++ ql/src/test/results/clientpositive/llap/vector_binary_join_groupby.q.out @@ -174,8 +174,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 21) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -256,8 +258,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -368,9 +372,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 10 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: bin (type: binary) mode: hash @@ -411,9 +417,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: binary) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out index f06d49a..1e8d679 100644 --- ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out +++ ql/src/test/results/clientpositive/llap/vector_cast_constant.q.out @@ -147,9 +147,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgLong(ConstantVectorExpression(val 50) -> 11:long) -> struct, VectorUDAFAvgDouble(ConstantVectorExpression(val 50.0) -> 12:double) -> struct, VectorUDAFAvgDecimal(ConstantVectorExpression(val 50) -> 13:decimal(10,0)) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgLong(ConstantVectorExpression(val 50) -> 11:long) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDouble(ConstantVectorExpression(val 50.0) -> 12:double) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDecimal(ConstantVectorExpression(val 50) -> 13:decimal(10,0)) -> struct output type STRUCT requires PRIMITIVE IS false keys: _col0 (type: int) diff --git ql/src/test/results/clientpositive/llap/vector_char_2.q.out ql/src/test/results/clientpositive/llap/vector_char_2.q.out index c330097..bd718e5 100644 --- ql/src/test/results/clientpositive/llap/vector_char_2.q.out +++ ql/src/test/results/clientpositive/llap/vector_char_2.q.out @@ -98,9 +98,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 2) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] keys: _col0 (type: char(20)) mode: hash @@ -143,9 +145,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 1) -> bigint, VectorUDAFCountMerge(col 2) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0, 1] keys: KEY._col0 (type: char(20)) mode: mergepartial @@ -296,9 +300,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 2) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] keys: _col0 (type: char(20)) mode: hash @@ -341,9 +347,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 1) -> bigint, VectorUDAFCountMerge(col 2) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0, 1] keys: KEY._col0 (type: char(20)) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_coalesce_2.q.out ql/src/test/results/clientpositive/llap/vector_coalesce_2.q.out index 2a3eff5..e994605 100644 --- ql/src/test/results/clientpositive/llap/vector_coalesce_2.q.out +++ ql/src/test/results/clientpositive/llap/vector_coalesce_2.q.out @@ -54,8 +54,10 @@ STAGE PLANS: Group By Operator aggregations: sum(_col1) Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null keys: _col0 (type: string) mode: hash @@ -75,8 +77,10 @@ STAGE PLANS: Group By Operator aggregations: sum(VALUE._col0) Group By Vectorization: + groupByMode: MERGEPARTIAL vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null keys: KEY._col0 (type: string) mode: mergepartial @@ -226,9 +230,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 4) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: string) mode: hash @@ -269,9 +275,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_count.q.out ql/src/test/results/clientpositive/llap/vector_count.q.out index a6e2f59..0dc7aca 100644 --- ql/src/test/results/clientpositive/llap/vector_count.q.out +++ ql/src/test/results/clientpositive/llap/vector_count.q.out @@ -84,9 +84,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 1) -> bigint, VectorUDAFCount(col 2) -> bigint, VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1, col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] keys: a (type: int), b (type: int), c (type: int) mode: hash @@ -194,9 +196,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 4:long) -> bigint, VectorUDAFCountStar(*) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 1) -> bigint, VectorUDAFCount(col 2) -> bigint, VectorUDAFCount(col 3) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 1) -> bigint, VectorUDAFCount(col 2) -> bigint, VectorUDAFCount(col 3) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 1) -> bigint, VectorUDAFCount(col 2) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 1) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 1) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1, col 2, col 3 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20] keys: _col1 (type: int), _col2 (type: int), _col3 (type: int), _col4 (type: int) mode: hash diff --git ql/src/test/results/clientpositive/llap/vector_count_distinct.q.out ql/src/test/results/clientpositive/llap/vector_count_distinct.q.out index 3c03787..86cd529 100644 --- ql/src/test/results/clientpositive/llap/vector_count_distinct.q.out +++ ql/src/test/results/clientpositive/llap/vector_count_distinct.q.out @@ -1267,9 +1267,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 16 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: ws_order_number (type: int) mode: hash @@ -1307,9 +1309,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -1320,8 +1324,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -1349,8 +1355,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_decimal_aggregate.q.out ql/src/test/results/clientpositive/llap/vector_decimal_aggregate.q.out index 44119b2..d5de0df 100644 --- ql/src/test/results/clientpositive/llap/vector_decimal_aggregate.q.out +++ ql/src/test/results/clientpositive/llap/vector_decimal_aggregate.q.out @@ -71,9 +71,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 1) -> bigint, VectorUDAFMaxDecimal(col 1) -> decimal(20,10), VectorUDAFMinDecimal(col 1) -> decimal(20,10), VectorUDAFSumDecimal(col 1) -> decimal(38,18), VectorUDAFCount(col 2) -> bigint, VectorUDAFMaxDecimal(col 2) -> decimal(23,14), VectorUDAFMinDecimal(col 2) -> decimal(23,14), VectorUDAFSumDecimal(col 2) -> decimal(38,18), VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 3 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8] keys: cint (type: int) mode: hash @@ -114,9 +116,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint, VectorUDAFMaxDecimal(col 2) -> decimal(20,10), VectorUDAFMinDecimal(col 3) -> decimal(20,10), VectorUDAFSumDecimal(col 4) -> decimal(38,18), VectorUDAFCountMerge(col 5) -> bigint, VectorUDAFMaxDecimal(col 6) -> decimal(23,14), VectorUDAFMinDecimal(col 7) -> decimal(23,14), VectorUDAFSumDecimal(col 8) -> decimal(38,18), VectorUDAFCountMerge(col 9) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8] keys: KEY._col0 (type: int) mode: mergepartial @@ -231,9 +235,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 1) -> bigint, VectorUDAFMaxDecimal(col 1) -> decimal(20,10), VectorUDAFMinDecimal(col 1) -> decimal(20,10), VectorUDAFSumDecimal(col 1) -> decimal(38,18), VectorUDAFAvgDecimal(col 1) -> struct, VectorUDAFStdPopDecimal(col 1) -> struct, VectorUDAFStdSampDecimal(col 1) -> struct, VectorUDAFCount(col 2) -> bigint, VectorUDAFMaxDecimal(col 2) -> decimal(23,14), VectorUDAFMinDecimal(col 2) -> decimal(23,14), VectorUDAFSumDecimal(col 2) -> decimal(38,18), VectorUDAFAvgDecimal(col 2) -> struct, VectorUDAFStdPopDecimal(col 2) -> struct, VectorUDAFStdSampDecimal(col 2) -> struct, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 3 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgDecimal(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopDecimal(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampDecimal(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDecimal(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopDecimal(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampDecimal(col 2) -> struct output type STRUCT requires PRIMITIVE IS false keys: cint (type: int) diff --git ql/src/test/results/clientpositive/llap/vector_decimal_precision.q.out ql/src/test/results/clientpositive/llap/vector_decimal_precision.q.out index 5d62086..4bb0f9a 100644 --- ql/src/test/results/clientpositive/llap/vector_decimal_precision.q.out +++ ql/src/test/results/clientpositive/llap/vector_decimal_precision.q.out @@ -586,8 +586,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgDecimal(col 0) -> struct, VectorUDAFSumDecimal(col 0) -> decimal(38,18) className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgDecimal(col 0) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash diff --git ql/src/test/results/clientpositive/llap/vector_distinct_2.q.out ql/src/test/results/clientpositive/llap/vector_distinct_2.q.out index 84022f8..f77ffa9 100644 --- ql/src/test/results/clientpositive/llap/vector_distinct_2.q.out +++ ql/src/test/results/clientpositive/llap/vector_distinct_2.q.out @@ -142,9 +142,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 8 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: t (type: tinyint), s (type: string) mode: hash @@ -182,9 +184,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: tinyint), KEY._col1 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_empty_where.q.out ql/src/test/results/clientpositive/llap/vector_empty_where.q.out index f582ca3..422ff73 100644 --- ql/src/test/results/clientpositive/llap/vector_empty_where.q.out +++ ql/src/test/results/clientpositive/llap/vector_empty_where.q.out @@ -47,9 +47,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: cint (type: int) mode: hash @@ -87,9 +89,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -100,8 +104,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -129,8 +135,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -202,9 +210,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: cint (type: int) mode: hash @@ -242,9 +252,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -255,8 +267,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -284,8 +298,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -365,9 +381,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: cint (type: int) mode: hash @@ -405,9 +423,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -418,8 +438,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -447,8 +469,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -528,9 +552,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: cint (type: int) mode: hash @@ -568,9 +594,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -581,8 +609,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -610,8 +640,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_groupby4.q.out ql/src/test/results/clientpositive/llap/vector_groupby4.q.out index 3b3b801..105420b 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby4.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby4.q.out @@ -94,9 +94,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: PARTIAL1 vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [] keys: KEY._col0 (type: string) mode: partial1 @@ -124,9 +126,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [] keys: KEY._col0 (type: string) mode: final diff --git ql/src/test/results/clientpositive/llap/vector_groupby6.q.out ql/src/test/results/clientpositive/llap/vector_groupby6.q.out index 7e21493..362faf2 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby6.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby6.q.out @@ -94,9 +94,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: PARTIAL1 vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [] keys: KEY._col0 (type: string) mode: partial1 @@ -124,9 +126,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [] keys: KEY._col0 (type: string) mode: final diff --git ql/src/test/results/clientpositive/llap/vector_groupby_3.q.out ql/src/test/results/clientpositive/llap/vector_groupby_3.q.out index 5063f06..5cfa532 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby_3.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby_3.q.out @@ -144,9 +144,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 8 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: t (type: tinyint), s (type: string) mode: hash @@ -187,9 +189,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 2) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: tinyint), KEY._col1 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_groupby_grouping_id3.q.out ql/src/test/results/clientpositive/llap/vector_groupby_grouping_id3.q.out index cfc87fb..90fe35b 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby_grouping_id3.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby_grouping_id3.q.out @@ -79,9 +79,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1, ConstantVectorExpression(val 0) -> 2:long native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: key (type: int), value (type: int), 0 (type: int) mode: hash @@ -143,9 +145,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1, ConstantVectorExpression(val 1) -> 4:long native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: int), KEY._col1 (type: int), 1 (type: int) mode: mergepartial @@ -251,9 +255,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1, ConstantVectorExpression(val 0) -> 2:long native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: int), _col1 (type: int), 0 (type: int) mode: hash @@ -306,9 +312,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1, col 2 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: int), KEY._col1 (type: int), KEY._col2 (type: int) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_groupby_mapjoin.q.out ql/src/test/results/clientpositive/llap/vector_groupby_mapjoin.q.out index 1b1ec9e..dd9cf48 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby_mapjoin.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby_mapjoin.q.out @@ -131,8 +131,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint, VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] mode: hash outputColumnNames: _col0, _col1 @@ -166,9 +168,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: key (type: string) mode: hash @@ -236,8 +240,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint, VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1] mode: mergepartial outputColumnNames: _col0, _col1 @@ -263,9 +269,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out index 0ba6195..b9d20e5 100644 --- ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out +++ ql/src/test/results/clientpositive/llap/vector_groupby_reduce.q.out @@ -11,18 +11,18 @@ PREHOOK: query: create table store_sales_txt ss_promo_sk int, ss_ticket_number int, ss_quantity int, - ss_wholesale_cost float, - ss_list_price float, - ss_sales_price float, - ss_ext_discount_amt float, - ss_ext_sales_price float, - ss_ext_wholesale_cost float, - ss_ext_list_price float, - ss_ext_tax float, - ss_coupon_amt float, - ss_net_paid float, - ss_net_paid_inc_tax float, - ss_net_profit float + ss_wholesale_cost double, + ss_list_price double, + ss_sales_price double, + ss_ext_discount_amt double, + ss_ext_sales_price double, + ss_ext_wholesale_cost double, + ss_ext_list_price double, + ss_ext_tax double, + ss_coupon_amt double, + ss_net_paid double, + ss_net_paid_inc_tax double, + ss_net_profit double ) row format delimited fields terminated by '|' stored as textfile @@ -42,18 +42,18 @@ POSTHOOK: query: create table store_sales_txt ss_promo_sk int, ss_ticket_number int, ss_quantity int, - ss_wholesale_cost float, - ss_list_price float, - ss_sales_price float, - ss_ext_discount_amt float, - ss_ext_sales_price float, - ss_ext_wholesale_cost float, - ss_ext_list_price float, - ss_ext_tax float, - ss_coupon_amt float, - ss_net_paid float, - ss_net_paid_inc_tax float, - ss_net_profit float + ss_wholesale_cost double, + ss_list_price double, + ss_sales_price double, + ss_ext_discount_amt double, + ss_ext_sales_price double, + ss_ext_wholesale_cost double, + ss_ext_list_price double, + ss_ext_tax double, + ss_coupon_amt double, + ss_net_paid double, + ss_net_paid_inc_tax double, + ss_net_profit double ) row format delimited fields terminated by '|' stored as textfile @@ -81,18 +81,19 @@ PREHOOK: query: create table store_sales ss_promo_sk int, ss_ticket_number int, ss_quantity int, - ss_wholesale_cost float, - ss_list_price float, - ss_sales_price float, - ss_ext_discount_amt float, - ss_ext_sales_price float, - ss_ext_wholesale_cost float, - ss_ext_list_price float, - ss_ext_tax float, - ss_coupon_amt float, - ss_net_paid float, - ss_net_paid_inc_tax float, - ss_net_profit float + ss_wholesale_cost double, + ss_wholesale_cost_decimal decimal(38,18), + ss_list_price double, + ss_sales_price double, + ss_ext_discount_amt double, + ss_ext_sales_price double, + ss_ext_wholesale_cost double, + ss_ext_list_price double, + ss_ext_tax double, + ss_coupon_amt double, + ss_net_paid double, + ss_net_paid_inc_tax double, + ss_net_profit double ) stored as orc tblproperties ("orc.stripe.size"="33554432", "orc.compress.size"="16384") @@ -112,18 +113,19 @@ POSTHOOK: query: create table store_sales ss_promo_sk int, ss_ticket_number int, ss_quantity int, - ss_wholesale_cost float, - ss_list_price float, - ss_sales_price float, - ss_ext_discount_amt float, - ss_ext_sales_price float, - ss_ext_wholesale_cost float, - ss_ext_list_price float, - ss_ext_tax float, - ss_coupon_amt float, - ss_net_paid float, - ss_net_paid_inc_tax float, - ss_net_profit float + ss_wholesale_cost double, + ss_wholesale_cost_decimal decimal(38,18), + ss_list_price double, + ss_sales_price double, + ss_ext_discount_amt double, + ss_ext_sales_price double, + ss_ext_wholesale_cost double, + ss_ext_list_price double, + ss_ext_tax double, + ss_coupon_amt double, + ss_net_paid double, + ss_net_paid_inc_tax double, + ss_net_profit double ) stored as orc tblproperties ("orc.stripe.size"="33554432", "orc.compress.size"="16384") @@ -144,6 +146,7 @@ ss_sold_date_sk , ss_ticket_number , ss_quantity , ss_wholesale_cost , + cast(ss_wholesale_cost as decimal(38,18)), ss_list_price , ss_sales_price , ss_ext_discount_amt , @@ -173,6 +176,7 @@ ss_sold_date_sk , ss_ticket_number , ss_quantity , ss_wholesale_cost , + cast(ss_wholesale_cost as decimal(38,18)), ss_list_price , ss_sales_price , ss_ext_discount_amt , @@ -190,27 +194,28 @@ POSTHOOK: Input: default@store_sales_txt POSTHOOK: Output: default@store_sales POSTHOOK: Lineage: store_sales.ss_addr_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_addr_sk, type:int, comment:null), ] POSTHOOK: Lineage: store_sales.ss_cdemo_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_cdemo_sk, type:int, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_coupon_amt SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_coupon_amt, type:float, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_coupon_amt SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_coupon_amt, type:double, comment:null), ] POSTHOOK: Lineage: store_sales.ss_customer_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_customer_sk, type:int, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_ext_discount_amt SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_discount_amt, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_ext_list_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_list_price, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_ext_sales_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_sales_price, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_ext_tax SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_tax, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_ext_wholesale_cost SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_wholesale_cost, type:float, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_ext_discount_amt SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_discount_amt, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_ext_list_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_list_price, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_ext_sales_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_sales_price, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_ext_tax SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_tax, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_ext_wholesale_cost SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ext_wholesale_cost, type:double, comment:null), ] POSTHOOK: Lineage: store_sales.ss_hdemo_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_hdemo_sk, type:int, comment:null), ] POSTHOOK: Lineage: store_sales.ss_item_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_item_sk, type:int, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_list_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_list_price, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_net_paid SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_net_paid, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_net_paid_inc_tax SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_net_paid_inc_tax, type:float, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_net_profit SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_net_profit, type:float, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_list_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_list_price, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_net_paid SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_net_paid, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_net_paid_inc_tax SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_net_paid_inc_tax, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_net_profit SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_net_profit, type:double, comment:null), ] POSTHOOK: Lineage: store_sales.ss_promo_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_promo_sk, type:int, comment:null), ] POSTHOOK: Lineage: store_sales.ss_quantity SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_quantity, type:int, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_sales_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_sales_price, type:float, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_sales_price SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_sales_price, type:double, comment:null), ] POSTHOOK: Lineage: store_sales.ss_sold_date_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_sold_date_sk, type:int, comment:null), ] POSTHOOK: Lineage: store_sales.ss_sold_time_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_sold_time_sk, type:int, comment:null), ] POSTHOOK: Lineage: store_sales.ss_store_sk SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_store_sk, type:int, comment:null), ] POSTHOOK: Lineage: store_sales.ss_ticket_number SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_ticket_number, type:int, comment:null), ] -POSTHOOK: Lineage: store_sales.ss_wholesale_cost SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_wholesale_cost, type:float, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_wholesale_cost SIMPLE [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_wholesale_cost, type:double, comment:null), ] +POSTHOOK: Lineage: store_sales.ss_wholesale_cost_decimal EXPRESSION [(store_sales_txt)store_sales_txt.FieldSchema(name:ss_wholesale_cost, type:double, comment:null), ] PREHOOK: query: explain vectorization expression select ss_ticket_number @@ -250,10 +255,10 @@ STAGE PLANS: Map Operator Tree: TableScan alias: store_sales - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE TableScan Vectorization: native: true - projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] Select Operator expressions: ss_ticket_number (type: int) outputColumnNames: ss_ticket_number @@ -261,18 +266,20 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumns: [9] - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 9 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: ss_ticket_number (type: int) mode: hash outputColumnNames: _col0 - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int) sort order: + @@ -282,7 +289,7 @@ STAGE PLANS: native: false nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true nativeConditionsNotMet: No TopN IS false - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 Execution mode: vectorized, llap LLAP IO: all inputs @@ -307,14 +314,16 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int) sort order: + @@ -323,7 +332,7 @@ STAGE PLANS: native: false nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true nativeConditionsNotMet: No TopN IS false - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE TopN Hash Memory Usage: 0.1 Reducer 3 Execution mode: vectorized, llap @@ -342,19 +351,19 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumns: [0] - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE Limit Number of rows: 20 Limit Vectorization: className: VectorLimitOperator native: true - Statistics: Num rows: 20 Data size: 1760 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 20 Data size: 4820 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 20 Data size: 1760 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 20 Data size: 4820 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -451,10 +460,10 @@ STAGE PLANS: Map Operator Tree: TableScan alias: store_sales - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE TableScan Vectorization: native: true - projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] Select Operator expressions: ss_ticket_number (type: int) outputColumnNames: ss_ticket_number @@ -462,18 +471,20 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumns: [9] - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 9 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: ss_ticket_number (type: int) mode: hash outputColumnNames: _col0 - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int) sort order: + @@ -482,7 +493,7 @@ STAGE PLANS: className: VectorReduceSinkLongOperator native: true nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -506,27 +517,31 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial outputColumnNames: _col0 - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE Group By Operator aggregations: min(_col0) Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> int className: VectorGroupByOperator + groupByMode: COMPLETE vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0] keys: _col0 (type: int) mode: complete outputColumnNames: _col0, _col1 - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: _col1 (type: int) outputColumnNames: _col0 @@ -534,7 +549,7 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumns: [1] - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int) sort order: + @@ -542,7 +557,7 @@ STAGE PLANS: className: VectorReduceSinkObjectHashOperator native: true nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -560,13 +575,13 @@ STAGE PLANS: className: VectorSelectOperator native: true projectedOutputColumns: [0] - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -688,24 +703,26 @@ POSTHOOK: Input: default@store_sales 82 PREHOOK: query: explain vectorization expression select - ss_ticket_number, sum(ss_item_sk), sum(q) + ss_ticket_number, sum(ss_item_sk), sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales + where ss_ticket_number = 1 group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number order by ss_ticket_number PREHOOK: type: QUERY POSTHOOK: query: explain vectorization expression select - ss_ticket_number, sum(ss_item_sk), sum(q) + ss_ticket_number, sum(ss_item_sk), sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales + where ss_ticket_number = 1 group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number order by ss_ticket_number @@ -725,47 +742,57 @@ STAGE PLANS: Edges: Reducer 2 <- Map 1 (SIMPLE_EDGE) Reducer 3 <- Reducer 2 (SIMPLE_EDGE) + Reducer 4 <- Reducer 3 (CUSTOM_SIMPLE_EDGE) #### A masked pattern was here #### Vertices: Map 1 Map Operator Tree: TableScan alias: store_sales - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE TableScan Vectorization: native: true - projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] - Select Operator - expressions: ss_item_sk (type: int), ss_ticket_number (type: int), ss_quantity (type: int) - outputColumnNames: ss_item_sk, ss_ticket_number, ss_quantity - Select Vectorization: - className: VectorSelectOperator + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] + Filter Operator + Filter Vectorization: + className: VectorFilterOperator native: true - projectedOutputColumns: [2, 9, 10] - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE - Group By Operator - aggregations: min(ss_quantity) - Group By Vectorization: - aggregators: VectorUDAFMinLong(col 10) -> int - className: VectorGroupByOperator - vectorOutput: true - keyExpressions: col 9, col 2 - native: false - projectedOutputColumns: [0] - keys: ss_ticket_number (type: int), ss_item_sk (type: int) - mode: hash - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: int) - sort order: ++ - Map-reduce partition columns: _col0 (type: int) - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE - value expressions: _col2 (type: int) + predicateExpression: FilterLongColEqualLongScalar(col 9, val 1) -> boolean + predicate: (ss_ticket_number = 1) (type: boolean) + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: ss_item_sk (type: int), ss_quantity (type: int), ss_wholesale_cost (type: double), ss_wholesale_cost_decimal (type: decimal(38,18)) + outputColumnNames: ss_item_sk, ss_quantity, ss_wholesale_cost, ss_wholesale_cost_decimal + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumns: [2, 10, 11, 12] + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE + Group By Operator + aggregations: min(ss_quantity), max(ss_wholesale_cost), max(ss_wholesale_cost_decimal) + Group By Vectorization: + aggregators: VectorUDAFMinLong(col 10) -> int, VectorUDAFMaxDouble(col 11) -> double, VectorUDAFMaxDecimal(col 12) -> decimal(38,18) + className: VectorGroupByOperator + groupByMode: HASH + vectorOutput: true + keyExpressions: col 2 + native: false + vectorProcessingMode: HASH + projectedOutputColumns: [0, 1, 2] + keys: ss_item_sk (type: int) + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: int) + sort order: + + Map-reduce partition columns: _col0 (type: int) + Reduce Sink Vectorization: + className: VectorReduceSinkLongOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: int), _col2 (type: double), _col3 (type: decimal(38,18)) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -781,55 +808,79 @@ STAGE PLANS: Reduce Vectorization: enabled: true enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true - groupByVectorOutput: true + groupByVectorOutput: false allNative: false usesVectorUDFAdaptor: false vectorized: true Reduce Operator Tree: Group By Operator - aggregations: min(VALUE._col0) + aggregations: min(VALUE._col0), max(VALUE._col1), max(VALUE._col2) Group By Vectorization: - aggregators: VectorUDAFMinLong(col 2) -> int + aggregators: VectorUDAFMinLong(col 1) -> int, VectorUDAFMaxDouble(col 2) -> double, VectorUDAFMaxDecimal(col 3) -> decimal(38,18) className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true - keyExpressions: col 0, col 1 + keyExpressions: col 0 native: false - projectedOutputColumns: [0] - keys: KEY._col0 (type: int), KEY._col1 (type: int) + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumns: [0, 1, 2] + keys: KEY._col0 (type: int) mode: mergepartial - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + outputColumnNames: _col0, _col1, _col2, _col3 + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: int), _col0 (type: int), _col2 (type: int) - outputColumnNames: _col0, _col1, _col2 + expressions: _col0 (type: int), _col1 (type: int), _col2 (type: double), _col3 (type: decimal(38,18)) + outputColumnNames: _col1, _col2, _col3, _col4 Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumns: [1, 0, 2] - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + projectedOutputColumns: [0, 1, 2, 3] + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE Group By Operator - aggregations: sum(_col0), sum(_col2) + aggregations: sum(_col1), sum(_col2), avg(_col2), sum(_col3), avg(_col3), sum(_col4), avg(_col4) Group By Vectorization: - aggregators: VectorUDAFSumLong(col 1) -> bigint, VectorUDAFSumLong(col 2) -> bigint + aggregators: VectorUDAFSumLong(col 0) -> bigint, VectorUDAFSumLong(col 1) -> bigint, VectorUDAFAvgLong(col 1) -> struct, VectorUDAFSumDouble(col 2) -> double, VectorUDAFAvgDouble(col 2) -> struct, VectorUDAFSumDecimal(col 3) -> decimal(38,18), VectorUDAFAvgDecimal(col 3) -> struct className: VectorGroupByOperator - vectorOutput: true - keyExpressions: col 0 + groupByMode: HASH + vectorOutput: false + keyExpressions: ConstantVectorExpression(val 1) -> 4:long native: false - projectedOutputColumns: [0, 1] - keys: _col1 (type: int) - mode: complete - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + vectorProcessingMode: HASH + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6] + vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDouble(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDecimal(col 3) -> struct output type STRUCT requires PRIMITIVE IS false + keys: 1 (type: int) + mode: hash + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int) sort order: + - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE - value expressions: _col1 (type: bigint), _col2 (type: bigint) + Map-reduce partition columns: _col0 (type: int) + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint), _col2 (type: bigint), _col3 (type: struct), _col4 (type: double), _col5 (type: struct), _col6 (type: decimal(38,18)), _col7 (type: struct) Reducer 3 + Execution mode: llap + Reduce Vectorization: + enabled: true + enableConditionsMet: hive.vectorized.execution.reduce.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true + notVectorizedReason: Aggregation Function UDF avg parameter expression for GROUPBY operator: Data type struct of Column[VALUE._col2] not supported + vectorized: false + Reduce Operator Tree: + Group By Operator + aggregations: sum(VALUE._col0), sum(VALUE._col1), avg(VALUE._col2), sum(VALUE._col3), avg(VALUE._col4), sum(VALUE._col5), avg(VALUE._col6) + keys: KEY._col0 (type: int) + mode: mergepartial + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 125 Data size: 30150 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col1 (type: bigint), _col2 (type: bigint), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: decimal(38,18)), _col7 (type: decimal(38,18)) + outputColumnNames: _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 125 Data size: 30150 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + sort order: + Statistics: Num rows: 125 Data size: 30150 Basic stats: COMPLETE Column stats: NONE + value expressions: _col1 (type: bigint), _col2 (type: bigint), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: decimal(38,18)), _col7 (type: decimal(38,18)) + Reducer 4 Execution mode: vectorized, llap Reduce Vectorization: enabled: true @@ -840,19 +891,20 @@ STAGE PLANS: vectorized: true Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: int), VALUE._col0 (type: bigint), VALUE._col1 (type: bigint) - outputColumnNames: _col0, _col1, _col2 + expressions: 1 (type: int), VALUE._col0 (type: bigint), VALUE._col1 (type: bigint), VALUE._col2 (type: double), VALUE._col3 (type: double), VALUE._col4 (type: double), VALUE._col5 (type: decimal(38,18)), VALUE._col6 (type: decimal(38,18)) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumns: [0, 1, 2] - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + projectedOutputColumns: [7, 0, 1, 2, 3, 4, 5, 6] + selectExpressions: ConstantVectorExpression(val 1) -> 7:long + Statistics: Num rows: 125 Data size: 30150 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 125 Data size: 30150 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -865,12 +917,13 @@ STAGE PLANS: ListSink PREHOOK: query: select - ss_ticket_number, sum(ss_item_sk), sum(q) + ss_ticket_number, sum(ss_item_sk), sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales + where ss_ticket_number = 1 group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number order by ss_ticket_number @@ -878,106 +931,26 @@ PREHOOK: type: QUERY PREHOOK: Input: default@store_sales #### A masked pattern was here #### POSTHOOK: query: select - ss_ticket_number, sum(ss_item_sk), sum(q) + ss_ticket_number, sum(ss_item_sk), sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales + where ss_ticket_number = 1 group by ss_ticket_number, ss_item_sk) a group by ss_ticket_number order by ss_ticket_number POSTHOOK: type: QUERY POSTHOOK: Input: default@store_sales #### A masked pattern was here #### -1 85411 816 -2 157365 812 -3 147948 710 -4 69545 411 -5 163232 840 -6 86307 627 -7 114874 563 -8 117953 662 -9 173250 690 -10 60338 602 -11 138545 657 -12 97181 586 -13 109484 555 -14 137333 442 -15 176829 652 -16 115004 654 -17 105008 460 -18 165135 738 -19 128252 831 -20 104789 374 -21 72771 469 -22 128153 449 -23 110253 603 -24 100662 1029 -25 118714 760 -26 81596 502 -27 164068 871 -28 58632 409 -29 133777 417 -30 130451 772 -31 114967 586 -32 142021 592 -33 151818 691 -34 112559 662 -35 137027 780 -36 118285 538 -37 94528 401 -38 81368 521 -39 101064 937 -40 84435 480 -41 112444 688 -42 95731 840 -43 57298 410 -44 159880 839 -45 68919 474 -46 111212 374 -47 78210 416 -48 94459 445 -49 90879 589 -50 37821 407 -51 124927 612 -52 98099 489 -53 138706 609 -54 87478 354 -55 90290 406 -56 78812 372 -57 101175 597 -58 88044 202 -59 104582 753 -60 99218 900 -61 66514 392 -62 126713 527 -63 98778 648 -64 131659 380 -65 86990 494 -66 108808 492 -67 75250 711 -68 91671 548 -69 92821 405 -70 75021 319 -71 124484 748 -72 161470 744 -73 104358 621 -74 88609 688 -75 92940 649 -76 75853 580 -77 124755 873 -78 98285 573 -79 160595 581 -80 151471 704 -81 105109 429 -82 55611 254 +1 85411 816 58.285714285714285 621.35 44.38214285714286 621.350000000000000000 44.382142857142857143 PREHOOK: query: explain vectorization expression select - ss_ticket_number, ss_item_sk, sum(q) + ss_ticket_number, ss_item_sk, sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales group by ss_ticket_number, ss_item_sk) a @@ -986,10 +959,10 @@ order by ss_ticket_number, ss_item_sk PREHOOK: type: QUERY POSTHOOK: query: explain vectorization expression select - ss_ticket_number, ss_item_sk, sum(q) + ss_ticket_number, ss_item_sk, sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales group by ss_ticket_number, ss_item_sk) a @@ -1017,31 +990,33 @@ STAGE PLANS: Map Operator Tree: TableScan alias: store_sales - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE TableScan Vectorization: native: true - projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22] + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23] Select Operator - expressions: ss_item_sk (type: int), ss_ticket_number (type: int), ss_quantity (type: int) - outputColumnNames: ss_item_sk, ss_ticket_number, ss_quantity + expressions: ss_item_sk (type: int), ss_ticket_number (type: int), ss_quantity (type: int), ss_wholesale_cost (type: double), ss_wholesale_cost_decimal (type: decimal(38,18)) + outputColumnNames: ss_item_sk, ss_ticket_number, ss_quantity, ss_wholesale_cost, ss_wholesale_cost_decimal Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumns: [2, 9, 10] - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + projectedOutputColumns: [2, 9, 10, 11, 12] + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Group By Operator - aggregations: min(ss_quantity) + aggregations: min(ss_quantity), max(ss_wholesale_cost), max(ss_wholesale_cost_decimal) Group By Vectorization: - aggregators: VectorUDAFMinLong(col 10) -> int + aggregators: VectorUDAFMinLong(col 10) -> int, VectorUDAFMaxDouble(col 11) -> double, VectorUDAFMaxDecimal(col 12) -> decimal(38,18) className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 9, col 2 native: false - projectedOutputColumns: [0] + vectorProcessingMode: HASH + projectedOutputColumns: [0, 1, 2] keys: ss_ticket_number (type: int), ss_item_sk (type: int) mode: hash - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE Reduce Output Operator key expressions: _col0 (type: int), _col1 (type: int) sort order: ++ @@ -1050,8 +1025,8 @@ STAGE PLANS: className: VectorReduceSinkMultiKeyOperator native: true nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 1000 Data size: 88276 Basic stats: COMPLETE Column stats: NONE - value expressions: _col2 (type: int) + Statistics: Num rows: 1000 Data size: 241204 Basic stats: COMPLETE Column stats: NONE + value expressions: _col2 (type: int), _col3 (type: double), _col4 (type: decimal(38,18)) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -1073,48 +1048,60 @@ STAGE PLANS: vectorized: true Reduce Operator Tree: Group By Operator - aggregations: min(VALUE._col0) + aggregations: min(VALUE._col0), max(VALUE._col1), max(VALUE._col2) Group By Vectorization: - aggregators: VectorUDAFMinLong(col 2) -> int + aggregators: VectorUDAFMinLong(col 2) -> int, VectorUDAFMaxDouble(col 3) -> double, VectorUDAFMaxDecimal(col 4) -> decimal(38,18) className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1 native: false - projectedOutputColumns: [0] + vectorProcessingMode: MERGE_PARTIAL + projectedOutputColumns: [0, 1, 2] keys: KEY._col0 (type: int), KEY._col1 (type: int) mode: mergepartial - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + outputColumnNames: _col0, _col1, _col2, _col3, _col4 + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE Select Operator - expressions: _col1 (type: int), _col0 (type: int), _col2 (type: int) - outputColumnNames: _col0, _col1, _col2 + expressions: _col1 (type: int), _col0 (type: int), _col2 (type: int), _col3 (type: double), _col4 (type: decimal(38,18)) + outputColumnNames: _col0, _col1, _col2, _col3, _col4 Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumns: [1, 0, 2] - Statistics: Num rows: 500 Data size: 44138 Basic stats: COMPLETE Column stats: NONE + projectedOutputColumns: [1, 0, 2, 3, 4] + Statistics: Num rows: 500 Data size: 120602 Basic stats: COMPLETE Column stats: NONE Group By Operator - aggregations: sum(_col2) + aggregations: sum(_col2), avg(_col2), sum(_col3), avg(_col3), sum(_col4), avg(_col4) Group By Vectorization: - aggregators: VectorUDAFSumLong(col 2) -> bigint + aggregators: VectorUDAFSumLong(col 2) -> bigint, VectorUDAFAvgLongComplete(col 2) -> double, VectorUDAFSumDouble(col 3) -> double, VectorUDAFAvgDoubleComplete(col 3) -> double, VectorUDAFSumDecimal(col 4) -> decimal(38,18), VectorUDAFAvgDecimalComplete(col 4) -> decimal(38,18) className: VectorGroupByOperator + groupByMode: COMPLETE vectorOutput: true keyExpressions: col 0, col 1 native: false - projectedOutputColumns: [0] + vectorProcessingMode: STREAMING + projectedOutputColumns: [0, 1, 2, 3, 4, 5] keys: _col1 (type: int), _col0 (type: int) mode: complete - outputColumnNames: _col0, _col1, _col2 - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE - Reduce Output Operator - key expressions: _col0 (type: int), _col1 (type: int) - sort order: ++ - Reduce Sink Vectorization: - className: VectorReduceSinkObjectHashOperator + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE + Select Operator + expressions: _col0 (type: int), _col1 (type: int), _col2 (type: bigint), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: decimal(38,18)), _col7 (type: decimal(38,18)) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 + Select Vectorization: + className: VectorSelectOperator native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE - value expressions: _col2 (type: bigint) + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7] + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE + Reduce Output Operator + key expressions: _col0 (type: int), _col1 (type: int) + sort order: ++ + Reduce Sink Vectorization: + className: VectorReduceSinkObjectHashOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE + value expressions: _col2 (type: bigint), _col3 (type: double), _col4 (type: double), _col5 (type: double), _col6 (type: decimal(38,18)), _col7 (type: decimal(38,18)) Reducer 3 Execution mode: vectorized, llap Reduce Vectorization: @@ -1126,19 +1113,19 @@ STAGE PLANS: vectorized: true Reduce Operator Tree: Select Operator - expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int), VALUE._col0 (type: bigint) - outputColumnNames: _col0, _col1, _col2 + expressions: KEY.reducesinkkey0 (type: int), KEY.reducesinkkey1 (type: int), VALUE._col0 (type: bigint), VALUE._col1 (type: double), VALUE._col2 (type: double), VALUE._col3 (type: double), VALUE._col4 (type: decimal(38,18)), VALUE._col5 (type: decimal(38,18)) + outputColumnNames: _col0, _col1, _col2, _col3, _col4, _col5, _col6, _col7 Select Vectorization: className: VectorSelectOperator native: true - projectedOutputColumns: [0, 1, 2] - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7] + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false File Sink Vectorization: className: VectorFileSinkOperator native: false - Statistics: Num rows: 250 Data size: 22069 Basic stats: COMPLETE Column stats: NONE + Statistics: Num rows: 250 Data size: 60301 Basic stats: COMPLETE Column stats: NONE table: input format: org.apache.hadoop.mapred.SequenceFileInputFormat output format: org.apache.hadoop.hive.ql.io.HiveSequenceFileOutputFormat @@ -1151,10 +1138,10 @@ STAGE PLANS: ListSink PREHOOK: query: select - ss_ticket_number, ss_item_sk, sum(q) + ss_ticket_number, ss_item_sk, sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales group by ss_ticket_number, ss_item_sk) a @@ -1164,10 +1151,10 @@ PREHOOK: type: QUERY PREHOOK: Input: default@store_sales #### A masked pattern was here #### POSTHOOK: query: select - ss_ticket_number, ss_item_sk, sum(q) + ss_ticket_number, ss_item_sk, sum(q), avg(q), sum(wc), avg(wc), sum(decwc), avg(decwc) from (select - ss_ticket_number, ss_item_sk, min(ss_quantity) q + ss_ticket_number, ss_item_sk, min(ss_quantity) q, max(ss_wholesale_cost) wc, max(ss_wholesale_cost_decimal) decwc from store_sales group by ss_ticket_number, ss_item_sk) a @@ -1176,1003 +1163,1003 @@ order by ss_ticket_number, ss_item_sk POSTHOOK: type: QUERY POSTHOOK: Input: default@store_sales #### A masked pattern was here #### -1 49 5 -1 173 65 -1 1553 50 -1 3248 58 -1 3617 79 -1 4553 100 -1 4583 72 -1 4682 44 -1 5527 88 -1 5981 14 -1 10993 91 -1 13283 37 -1 13538 14 -1 13631 99 -2 1363 4 -2 2930 36 -2 3740 49 -2 6928 65 -2 7654 25 -2 9436 79 -2 10768 30 -2 12068 74 -2 12223 78 -2 13340 71 -2 13927 93 -2 14701 58 -2 15085 88 -2 15782 62 -2 17420 NULL -3 246 96 -3 1531 NULL -3 3525 42 -3 4698 98 -3 5355 53 -3 10693 27 -3 12447 82 -3 13021 64 -3 14100 79 -3 14443 4 -3 15786 56 -3 16869 4 -3 17263 17 -3 17971 88 -4 163 17 -4 1576 74 -4 5350 86 -4 5515 23 -4 6988 23 -4 7990 56 -4 8452 27 -4 9685 21 -4 11036 41 -4 12790 43 -5 1808 NULL -5 1940 60 -5 5842 50 -5 6068 76 -5 6466 36 -5 11324 52 -5 11590 15 -5 12650 66 -5 13562 64 -5 13958 60 -5 14599 83 -5 14686 91 -5 15752 66 -5 16195 50 -5 16792 71 -6 2549 62 -6 2647 100 -6 3049 31 -6 3291 100 -6 6437 72 -6 8621 NULL -6 10355 94 -6 10895 1 -6 11705 61 -6 13245 64 -6 13513 42 -7 4627 9 -7 4795 73 -7 4833 88 -7 5183 51 -7 5905 69 -7 8955 54 -7 9751 4 -7 10487 52 -7 12571 82 -7 15179 12 -7 15333 NULL -7 17255 69 -8 665 31 -8 4183 90 -8 5929 83 -8 7115 54 -8 11365 7 -8 11893 95 -8 12041 95 -8 13427 87 -8 16671 20 -8 17119 51 -8 17545 49 -9 69 11 -9 889 6 -9 1185 62 -9 4623 34 -9 7945 83 -9 8334 71 -9 12027 27 -9 12969 59 -9 13483 NULL -9 13717 53 -9 15133 15 -9 16083 32 -9 16363 54 -9 16461 66 -9 16659 84 -9 17310 33 -10 755 74 -10 1425 92 -10 1511 76 -10 3433 83 -10 3933 52 -10 4357 17 -10 5863 47 -10 9811 28 -10 13803 66 -10 15447 67 -11 157 84 -11 1315 70 -11 7519 68 -11 7608 66 -11 9901 57 -11 10699 33 -11 11490 NULL -11 11991 38 -11 12438 16 -11 15157 96 -11 15649 33 -11 17226 11 -11 17395 85 -12 373 57 -12 1591 82 -12 4888 56 -12 6148 36 -12 6248 36 -12 9616 66 -12 9788 73 -12 13399 46 -12 14746 26 -12 14944 9 -12 15440 99 -13 868 NULL -13 1760 12 -13 1898 NULL -13 2108 9 -13 2191 NULL -13 4430 73 -13 5971 80 -13 6085 58 -13 6140 15 -13 6682 80 -13 7640 48 -13 7723 27 -13 10096 12 -13 11758 34 -13 16894 87 -13 17240 20 -14 177 41 -14 769 20 -14 4507 4 -14 10175 19 -14 11549 6 -14 11653 60 -14 11817 81 -14 12587 NULL -14 13069 77 -14 13515 57 -14 13845 17 -14 16741 46 -14 16929 14 -15 4241 21 -15 4505 59 -15 4777 28 -15 7391 98 -15 8336 15 -15 8353 NULL -15 8690 32 -15 8707 21 -15 10361 39 -15 11659 80 -15 13172 25 -15 16619 81 -15 17267 7 -15 17330 82 -15 17564 26 -15 17857 38 -16 457 60 -16 1888 4 -16 4144 94 -16 6008 59 -16 7504 51 -16 8887 35 -16 9769 42 -16 9790 17 -16 9997 94 -16 11168 86 -16 11920 29 -16 16226 13 -16 17246 70 -17 2092 37 -17 4678 34 -17 6811 70 -17 9214 57 -17 10543 54 -17 11203 21 -17 13177 45 -17 13826 32 -17 15781 76 -17 17683 34 -18 2440 40 -18 5251 41 -18 7378 94 -18 8779 9 -18 8884 18 -18 9886 62 -18 11584 76 -18 11890 7 -18 12602 81 -18 12826 93 -18 12860 18 -18 14011 95 -18 14372 76 -18 14377 15 -18 17995 13 -19 1094 48 -19 3133 96 -19 3376 84 -19 4882 84 -19 6772 97 -19 7087 1 -19 7814 29 -19 8662 97 -19 9094 49 -19 9346 39 -19 10558 82 -19 10651 46 -19 11914 59 -19 16330 NULL -19 17539 20 -20 1451 89 -20 2618 4 -20 5312 9 -20 5425 15 -20 5483 8 -20 6026 21 -20 7207 90 -20 8714 NULL -20 9086 4 -20 9800 32 -20 13601 17 -20 14935 NULL -20 15131 85 -21 230 48 -21 1810 59 -21 2870 50 -21 5170 45 -21 5998 51 -21 6476 49 -21 9187 14 -21 12266 47 -21 14368 18 -21 14396 88 -22 9985 70 -22 10474 31 -22 11599 66 -22 12415 10 -22 15310 15 -22 16396 85 -22 16922 88 -22 17392 14 -22 17660 70 -23 319 86 -23 7242 37 -23 8181 13 -23 8413 1 -23 9093 38 -23 9097 81 -23 11220 91 -23 11257 64 -23 12397 80 -23 15403 96 -23 17631 16 -24 407 53 -24 1389 72 -24 1795 21 -24 2497 85 -24 3103 73 -24 4425 57 -24 4749 28 -24 4873 41 -24 5653 92 -24 6043 1 -24 6751 82 -24 7375 97 -24 10265 93 -24 11551 48 -24 13303 97 -24 16483 89 -25 1333 55 -25 2150 100 -25 2608 76 -25 3454 100 -25 4880 29 -25 5954 34 -25 6955 40 -25 7874 65 -25 9472 48 -25 10159 24 -25 14488 26 -25 14635 68 -25 17000 40 -25 17752 55 -26 1989 26 -26 5053 4 -26 5385 97 -26 5721 81 -26 6647 64 -26 7337 45 -26 9679 18 -26 11895 77 -26 12851 56 -26 15039 34 -27 1305 44 -27 2137 96 -27 2671 92 -27 5831 61 -27 7139 59 -27 8167 28 -27 10757 15 -27 11441 15 -27 11509 65 -27 12237 89 -27 12749 31 -27 13885 66 -27 15025 26 -27 16029 59 -27 16419 65 -27 16767 60 -28 1807 98 -28 2817 8 -28 2967 29 -28 4483 78 -28 5437 15 -28 6411 3 -28 7965 93 -28 8043 58 -28 8407 14 -28 10295 13 -29 20 18 -29 1363 75 -29 2930 23 -29 3740 5 -29 7654 20 -29 9458 33 -29 10795 33 -29 12068 37 -29 12223 59 -29 13340 21 -29 13693 NULL -29 15085 40 -29 15626 NULL -29 15782 53 -30 217 91 -30 1951 59 -30 3238 16 -30 3506 15 -30 3928 87 -30 5431 77 -30 6752 69 -30 7870 7 -30 8666 21 -30 12572 33 -30 12670 20 -30 13579 75 -30 14848 62 -30 17348 62 -30 17875 78 -31 913 54 -31 4963 67 -31 6617 11 -31 6917 4 -31 7513 82 -31 11739 95 -31 14575 97 -31 14727 41 -31 15341 31 -31 15411 53 -31 16251 51 -32 1115 61 -32 2095 34 -32 2887 8 -32 4339 6 -32 4537 22 -32 4808 NULL -32 5798 87 -32 7547 24 -32 9683 26 -32 11005 46 -32 11348 41 -32 12134 21 -32 15001 57 -32 15644 34 -32 16421 74 -32 17659 51 -33 4798 27 -33 7300 3 -33 9649 36 -33 10376 21 -33 11119 92 -33 11756 26 -33 12643 89 -33 12760 54 -33 12964 80 -33 14125 66 -33 14158 82 -33 14692 93 -33 15478 22 -34 1526 91 -34 1717 53 -34 2312 6 -34 4118 88 -34 5197 63 -34 5449 9 -34 6193 61 -34 9325 3 -34 9766 83 -34 12016 42 -34 12290 53 -34 12512 60 -34 13814 20 -34 16324 30 -35 411 51 -35 2377 52 -35 3667 97 -35 4325 56 -35 5179 83 -35 11635 87 -35 11661 81 -35 14239 55 -35 15619 45 -35 15757 9 -35 17341 92 -35 17365 65 -35 17451 7 -36 1115 80 -36 2095 43 -36 2887 31 -36 7547 46 -36 11005 49 -36 11349 80 -36 15001 54 -36 15645 23 -36 16421 25 -36 17561 16 -36 17659 91 -37 2997 94 -37 7283 87 -37 10715 52 -37 10929 88 -37 13171 6 -37 15337 62 -37 16971 12 -37 17125 NULL -38 757 2 -38 2164 17 -38 3439 84 -38 4154 35 -38 5113 73 -38 6220 98 -38 7018 15 -38 7784 56 -38 8870 15 -38 9710 7 -38 10441 62 -38 15698 57 -39 386 89 -39 1598 64 -39 3476 73 -39 3943 64 -39 4190 86 -39 4957 24 -39 5393 98 -39 7097 78 -39 7118 67 -39 7604 49 -39 7697 24 -39 8078 54 -39 8411 96 -39 15491 54 -39 15625 17 -40 2854 71 -40 3490 65 -40 3985 63 -40 5098 35 -40 5318 87 -40 10094 80 -40 10912 23 -40 12050 NULL -40 13658 53 -40 16976 3 -41 10 50 -41 64 29 -41 3380 88 -41 5566 11 -41 6310 90 -41 7402 69 -41 7603 94 -41 9322 8 -41 10915 81 -41 14788 15 -41 15242 87 -41 15328 46 -41 16514 20 -42 619 69 -42 976 100 -42 1436 94 -42 2314 74 -42 2392 14 -42 2602 30 -42 3346 74 -42 3613 30 -42 6058 30 -42 6134 92 -42 8462 23 -42 9740 52 -42 10016 57 -42 10471 19 -42 12550 41 -42 15002 41 -43 2923 16 -43 3344 22 -43 3911 26 -43 4364 77 -43 4691 41 -43 5773 85 -43 5852 16 -43 11771 30 -43 14669 97 -44 2351 56 -44 2623 18 -44 7303 14 -44 7527 67 -44 9059 68 -44 11707 83 -44 12341 20 -44 13331 98 -44 13449 45 -44 14149 80 -44 15803 81 -44 16491 56 -44 16837 92 -44 16909 61 -45 811 62 -45 1479 49 -45 3265 98 -45 5309 18 -45 7363 87 -45 10115 68 -45 11095 40 -45 13133 46 -45 16349 6 -46 1960 12 -46 3010 67 -46 7040 33 -46 8065 NULL -46 11426 72 -46 13042 58 -46 15595 32 -46 16540 30 -46 17150 57 -46 17384 13 -47 254 NULL -47 481 30 -47 1132 66 -47 1916 71 -47 3085 51 -47 3202 7 -47 3878 NULL -47 4774 11 -47 5008 82 -47 5305 NULL -47 5468 7 -47 7214 1 -47 9770 33 -47 13246 47 -47 13477 10 -48 1761 22 -48 2820 4 -48 2829 65 -48 4431 39 -48 5971 29 -48 6085 1 -48 6684 44 -48 9199 88 -48 11259 NULL -48 12468 62 -48 13153 74 -48 17799 17 -49 749 60 -49 2135 4 -49 5342 69 -49 5852 47 -49 6805 40 -49 7141 94 -49 9049 68 -49 9553 71 -49 12737 48 -49 15155 84 -49 16361 4 -50 1280 69 -50 1312 30 -50 1909 53 -50 1984 40 -50 3097 64 -50 5023 NULL -50 7135 69 -50 16081 82 -51 422 21 -51 3091 28 -51 4687 6 -51 5029 12 -51 5059 51 -51 6565 33 -51 8384 79 -51 9311 90 -51 10133 54 -51 11234 NULL -51 12625 53 -51 13199 97 -51 17483 22 -51 17705 66 -52 2420 90 -52 3334 73 -52 6098 NULL -52 7606 45 -52 11488 76 -52 15649 29 -52 16646 48 -52 17402 91 -52 17456 37 -53 1114 40 -53 2095 62 -53 2786 70 -53 2887 39 -53 7546 58 -53 11348 38 -53 13220 76 -53 13795 38 -53 15991 37 -53 16420 14 -53 16648 79 -53 17296 43 -53 17560 15 -54 702 40 -54 825 50 -54 1165 62 -54 3861 NULL -54 6517 40 -54 9159 75 -54 14737 38 -54 16059 15 -54 16974 NULL -54 17479 34 -55 1339 16 -55 3001 7 -55 5137 33 -55 9703 44 -55 12170 92 -55 12205 90 -55 14135 36 -55 14923 71 -55 17677 17 -56 4242 2 -56 4506 57 -56 8353 35 -56 8691 59 -56 8707 68 -56 10362 54 -56 16620 23 -56 17331 74 -57 3253 71 -57 4028 88 -57 4933 22 -57 12596 91 -57 12721 62 -57 12740 52 -57 15182 86 -57 17729 26 -57 17993 99 -58 1829 52 -58 3848 6 -58 5117 2 -58 7649 19 -58 9743 62 -58 10802 14 -58 15635 6 -58 16472 6 -58 16949 35 -59 3133 92 -59 3546 22 -59 5772 70 -59 7087 80 -59 8010 46 -59 8335 36 -59 9348 62 -59 9397 92 -59 10651 100 -59 11916 19 -59 12858 90 -59 14529 44 -60 97 50 -60 555 62 -60 633 71 -60 999 43 -60 1117 78 -60 1573 90 -60 4041 25 -60 4235 28 -60 4513 72 -60 4937 22 -60 7231 95 -60 10277 62 -60 10393 75 -60 13975 14 -60 16887 25 -60 17755 88 -61 1106 4 -61 2264 36 -61 3362 48 -61 4567 26 -61 5528 78 -61 6380 77 -61 7591 78 -61 8924 11 -61 10330 8 -61 16462 26 -62 4093 94 -62 6403 NULL -62 8457 37 -62 10149 75 -62 12163 29 -62 12199 5 -62 12407 NULL -62 13559 80 -62 15399 74 -62 15733 40 -62 16151 93 -63 4488 73 -63 5079 79 -63 5217 66 -63 5658 99 -63 9319 80 -63 11370 38 -63 11946 85 -63 13339 19 -63 15793 40 -63 16569 69 -64 1213 NULL -64 3090 87 -64 3963 NULL -64 11835 82 -64 13224 NULL -64 14407 8 -64 15867 59 -64 15936 30 -64 16921 19 -64 17586 78 -64 17617 17 -65 2287 100 -65 4227 42 -65 9625 51 -65 9847 54 -65 13897 40 -65 14905 85 -65 15177 55 -65 17025 67 -66 6507 76 -66 7033 65 -66 7227 66 -66 8197 41 -66 9237 29 -66 10019 10 -66 11419 66 -66 15629 20 -66 16745 91 -66 16795 28 -67 757 77 -67 2133 74 -67 3439 73 -67 4155 87 -67 5113 NULL -67 7020 79 -67 7507 77 -67 8469 59 -67 8871 71 -67 12087 70 -67 15699 44 -68 1387 74 -68 1603 57 -68 1820 54 -68 2035 22 -68 2296 52 -68 2564 83 -68 5162 23 -68 6763 77 -68 7765 NULL -68 12526 3 -68 12724 88 -68 17426 2 -68 17600 13 -69 322 45 -69 337 34 -69 4208 9 -69 4267 10 -69 6136 7 -69 7264 67 -69 7822 30 -69 8599 53 -69 11137 68 -69 13489 66 -69 13792 NULL -69 15448 16 -70 1592 53 -70 2462 NULL -70 3296 48 -70 3947 NULL -70 6185 82 -70 6425 NULL -70 8893 17 -70 9857 20 -70 14549 4 -70 17815 95 -71 457 75 -71 1888 4 -71 2098 51 -71 4144 49 -71 5858 NULL -71 6008 54 -71 7504 3 -71 8887 10 -71 9274 36 -71 9769 79 -71 9790 96 -71 9997 26 -71 10108 66 -71 10288 30 -71 11168 79 -71 17246 90 -72 1535 9 -72 5917 85 -72 6113 45 -72 6671 13 -72 9860 26 -72 10427 66 -72 10753 16 -72 11741 62 -72 12788 29 -72 12901 57 -72 13085 94 -72 13423 62 -72 13904 37 -72 15587 87 -72 16765 56 -73 247 53 -73 1063 37 -73 3205 82 -73 4946 54 -73 6862 58 -73 10051 49 -73 12502 75 -73 15109 38 -73 16519 97 -73 16585 38 -73 17269 40 -74 326 29 -74 3104 78 -74 3175 23 -74 3278 NULL -74 3542 96 -74 3754 26 -74 5492 54 -74 7694 17 -74 8653 12 -74 9620 95 -74 10069 99 -74 13208 87 -74 16694 72 -75 607 20 -75 2948 25 -75 4625 73 -75 6938 89 -75 6953 71 -75 8726 6 -75 9905 54 -75 10217 85 -75 11039 70 -75 14186 63 -75 16796 93 -76 257 5 -76 465 2 -76 1107 16 -76 1503 97 -76 2265 98 -76 2869 32 -76 3363 25 -76 4237 48 -76 4567 40 -76 5529 78 -76 6381 50 -76 7591 27 -76 8925 6 -76 10331 3 -76 16463 53 -77 992 62 -77 1399 34 -77 2713 85 -77 3868 89 -77 6289 30 -77 7339 88 -77 7448 95 -77 7486 49 -77 8686 38 -77 9220 90 -77 11918 36 -77 12439 95 -77 13456 48 -77 14815 18 -77 16687 16 -78 901 3 -78 3304 50 -78 3856 27 -78 5965 78 -78 6044 59 -78 6110 43 -78 6500 76 -78 7576 87 -78 8611 79 -78 10507 6 -78 11209 7 -78 12706 19 -78 14996 39 -79 247 NULL -79 1063 85 -79 3205 48 -79 4947 35 -79 6864 1 -79 10051 10 -79 10524 36 -79 12504 81 -79 14322 41 -79 15109 NULL -79 15498 3 -79 15888 58 -79 16519 9 -79 16585 93 -79 17269 81 -80 998 93 -80 1519 25 -80 1573 40 -80 4040 66 -80 4513 NULL -80 4622 1 -80 7231 49 -80 7610 37 -80 10393 5 -80 12968 NULL -80 13717 91 -80 13975 13 -80 16363 84 -80 16886 77 -80 17308 29 -80 17755 94 -81 4486 31 -81 5078 75 -81 5216 64 -81 5656 24 -81 7166 7 -81 7663 79 -81 8918 37 -81 9319 36 -81 11107 36 -81 11368 26 -81 13339 6 -81 15793 8 -82 2572 53 -82 7862 75 -82 13138 59 -82 14998 49 -82 17041 18 +1 49 5 5.0 10.68 10.68 10.680000000000000000 10.680000000000000000 +1 173 65 65.0 27.16 27.16 27.160000000000000000 27.160000000000000000 +1 1553 50 50.0 67.71 67.71 67.710000000000000000 67.710000000000000000 +1 3248 58 58.0 4.57 4.57 4.570000000000000000 4.570000000000000000 +1 3617 79 79.0 11.41 11.41 11.410000000000000000 11.410000000000000000 +1 4553 100 100.0 25.08 25.08 25.080000000000000000 25.080000000000000000 +1 4583 72 72.0 84.72 84.72 84.720000000000000000 84.720000000000000000 +1 4682 44 44.0 31.07 31.07 31.070000000000000000 31.070000000000000000 +1 5527 88 88.0 52.41 52.41 52.410000000000000000 52.410000000000000000 +1 5981 14 14.0 57.37 57.37 57.370000000000000000 57.370000000000000000 +1 10993 91 91.0 93.48 93.48 93.480000000000000000 93.480000000000000000 +1 13283 37 37.0 63.63 63.63 63.630000000000000000 63.630000000000000000 +1 13538 14 14.0 11.54 11.54 11.540000000000000000 11.540000000000000000 +1 13631 99 99.0 80.52 80.52 80.520000000000000000 80.520000000000000000 +2 1363 4 4.0 13.46 13.46 13.460000000000000000 13.460000000000000000 +2 2930 36 36.0 61.23 61.23 61.230000000000000000 61.230000000000000000 +2 3740 49 49.0 6.55 6.55 6.550000000000000000 6.550000000000000000 +2 6928 65 65.0 93.86 93.86 93.860000000000000000 93.860000000000000000 +2 7654 25 25.0 74.26 74.26 74.260000000000000000 74.260000000000000000 +2 9436 79 79.0 88.02 88.02 88.020000000000000000 88.020000000000000000 +2 10768 30 30.0 2.27 2.27 2.270000000000000000 2.270000000000000000 +2 12068 74 74.0 16.55 16.55 16.550000000000000000 16.550000000000000000 +2 12223 78 78.0 65.71 65.71 65.710000000000000000 65.710000000000000000 +2 13340 71 71.0 36.01 36.01 36.010000000000000000 36.010000000000000000 +2 13927 93 93.0 35.87 35.87 35.870000000000000000 35.870000000000000000 +2 14701 58 58.0 53.09 53.09 53.090000000000000000 53.090000000000000000 +2 15085 88 88.0 64.43 64.43 64.430000000000000000 64.430000000000000000 +2 15782 62 62.0 77.97 77.97 77.970000000000000000 77.970000000000000000 +2 17420 NULL NULL 17.12 17.12 17.120000000000000000 17.120000000000000000 +3 246 96 96.0 98.02 98.02 98.020000000000000000 98.020000000000000000 +3 1531 NULL NULL NULL NULL NULL NULL +3 3525 42 42.0 97.03 97.03 97.030000000000000000 97.030000000000000000 +3 4698 98 98.0 85.0 85.0 85.000000000000000000 85.000000000000000000 +3 5355 53 53.0 23.04 23.04 23.040000000000000000 23.040000000000000000 +3 10693 27 27.0 37.04 37.04 37.040000000000000000 37.040000000000000000 +3 12447 82 82.0 56.14 56.14 56.140000000000000000 56.140000000000000000 +3 13021 64 64.0 74.69 74.69 74.690000000000000000 74.690000000000000000 +3 14100 79 79.0 44.66 44.66 44.660000000000000000 44.660000000000000000 +3 14443 4 4.0 95.75 95.75 95.750000000000000000 95.750000000000000000 +3 15786 56 56.0 4.31 4.31 4.310000000000000000 4.310000000000000000 +3 16869 4 4.0 75.67 75.67 75.670000000000000000 75.670000000000000000 +3 17263 17 17.0 72.38 72.38 72.380000000000000000 72.380000000000000000 +3 17971 88 88.0 27.95 27.95 27.950000000000000000 27.950000000000000000 +4 163 17 17.0 54.26 54.26 54.260000000000000000 54.260000000000000000 +4 1576 74 74.0 81.81 81.81 81.810000000000000000 81.810000000000000000 +4 5350 86 86.0 64.67 64.67 64.670000000000000000 64.670000000000000000 +4 5515 23 23.0 2.91 2.91 2.910000000000000000 2.910000000000000000 +4 6988 23 23.0 53.28 53.28 53.280000000000000000 53.280000000000000000 +4 7990 56 56.0 64.68 64.68 64.680000000000000000 64.680000000000000000 +4 8452 27 27.0 26.21 26.21 26.210000000000000000 26.210000000000000000 +4 9685 21 21.0 40.39 40.39 40.390000000000000000 40.390000000000000000 +4 11036 41 41.0 67.18 67.18 67.180000000000000000 67.180000000000000000 +4 12790 43 43.0 54.34 54.34 54.340000000000000000 54.340000000000000000 +5 1808 NULL NULL NULL NULL NULL NULL +5 1940 60 60.0 69.54 69.54 69.540000000000000000 69.540000000000000000 +5 5842 50 50.0 30.69 30.69 30.690000000000000000 30.690000000000000000 +5 6068 76 76.0 89.78 89.78 89.780000000000000000 89.780000000000000000 +5 6466 36 36.0 7.93 7.93 7.930000000000000000 7.930000000000000000 +5 11324 52 52.0 16.33 16.33 16.330000000000000000 16.330000000000000000 +5 11590 15 15.0 21.21 21.21 21.210000000000000000 21.210000000000000000 +5 12650 66 66.0 21.01 21.01 21.010000000000000000 21.010000000000000000 +5 13562 64 64.0 87.9 87.9 87.900000000000000000 87.900000000000000000 +5 13958 60 60.0 41.72 41.72 41.720000000000000000 41.720000000000000000 +5 14599 83 83.0 74.15 74.15 74.150000000000000000 74.150000000000000000 +5 14686 91 91.0 27.68 27.68 27.680000000000000000 27.680000000000000000 +5 15752 66 66.0 71.06 71.06 71.060000000000000000 71.060000000000000000 +5 16195 50 50.0 30.96 30.96 30.960000000000000000 30.960000000000000000 +5 16792 71 71.0 22.1 22.1 22.100000000000000000 22.100000000000000000 +6 2549 62 62.0 85.07 85.07 85.070000000000000000 85.070000000000000000 +6 2647 100 100.0 4.45 4.45 4.450000000000000000 4.450000000000000000 +6 3049 31 31.0 49.78 49.78 49.780000000000000000 49.780000000000000000 +6 3291 100 100.0 41.08 41.08 41.080000000000000000 41.080000000000000000 +6 6437 72 72.0 55.49 55.49 55.490000000000000000 55.490000000000000000 +6 8621 NULL NULL NULL NULL NULL NULL +6 10355 94 94.0 62.67 62.67 62.670000000000000000 62.670000000000000000 +6 10895 1 1.0 71.1 71.1 71.100000000000000000 71.100000000000000000 +6 11705 61 61.0 48.18 48.18 48.180000000000000000 48.180000000000000000 +6 13245 64 64.0 86.35 86.35 86.350000000000000000 86.350000000000000000 +6 13513 42 42.0 64.46 64.46 64.460000000000000000 64.460000000000000000 +7 4627 9 9.0 56.13 56.13 56.130000000000000000 56.130000000000000000 +7 4795 73 73.0 12.17 12.17 12.170000000000000000 12.170000000000000000 +7 4833 88 88.0 38.23 38.23 38.230000000000000000 38.230000000000000000 +7 5183 51 51.0 84.65 84.65 84.650000000000000000 84.650000000000000000 +7 5905 69 69.0 99.85 99.85 99.850000000000000000 99.850000000000000000 +7 8955 54 54.0 42.82 42.82 42.820000000000000000 42.820000000000000000 +7 9751 4 4.0 NULL NULL NULL NULL +7 10487 52 52.0 63.8 63.8 63.800000000000000000 63.800000000000000000 +7 12571 82 82.0 69.53 69.53 69.530000000000000000 69.530000000000000000 +7 15179 12 12.0 47.6 47.6 47.600000000000000000 47.600000000000000000 +7 15333 NULL NULL NULL NULL NULL NULL +7 17255 69 69.0 34.19 34.19 34.190000000000000000 34.190000000000000000 +8 665 31 31.0 15.64 15.64 15.640000000000000000 15.640000000000000000 +8 4183 90 90.0 81.63 81.63 81.630000000000000000 81.630000000000000000 +8 5929 83 83.0 14.11 14.11 14.110000000000000000 14.110000000000000000 +8 7115 54 54.0 36.99 36.99 36.990000000000000000 36.990000000000000000 +8 11365 7 7.0 18.65 18.65 18.650000000000000000 18.650000000000000000 +8 11893 95 95.0 21.29 21.29 21.290000000000000000 21.290000000000000000 +8 12041 95 95.0 91.8 91.8 91.800000000000000000 91.800000000000000000 +8 13427 87 87.0 31.78 31.78 31.780000000000000000 31.780000000000000000 +8 16671 20 20.0 18.95 18.95 18.950000000000000000 18.950000000000000000 +8 17119 51 51.0 8.04 8.04 8.040000000000000000 8.040000000000000000 +8 17545 49 49.0 72.15 72.15 72.150000000000000000 72.150000000000000000 +9 69 11 11.0 31.7 31.7 31.700000000000000000 31.700000000000000000 +9 889 6 6.0 27.17 27.17 27.170000000000000000 27.170000000000000000 +9 1185 62 62.0 55.68 55.68 55.680000000000000000 55.680000000000000000 +9 4623 34 34.0 2.97 2.97 2.970000000000000000 2.970000000000000000 +9 7945 83 83.0 8.1 8.1 8.100000000000000000 8.100000000000000000 +9 8334 71 71.0 34.79 34.79 34.790000000000000000 34.790000000000000000 +9 12027 27 27.0 98.68 98.68 98.680000000000000000 98.680000000000000000 +9 12969 59 59.0 88.31 88.31 88.310000000000000000 88.310000000000000000 +9 13483 NULL NULL 59.14 59.14 59.140000000000000000 59.140000000000000000 +9 13717 53 53.0 75.37 75.37 75.370000000000000000 75.370000000000000000 +9 15133 15 15.0 35.89 35.89 35.890000000000000000 35.890000000000000000 +9 16083 32 32.0 99.1 99.1 99.100000000000000000 99.100000000000000000 +9 16363 54 54.0 NULL NULL NULL NULL +9 16461 66 66.0 15.21 15.21 15.210000000000000000 15.210000000000000000 +9 16659 84 84.0 76.71 76.71 76.710000000000000000 76.710000000000000000 +9 17310 33 33.0 27.13 27.13 27.130000000000000000 27.130000000000000000 +10 755 74 74.0 82.24 82.24 82.240000000000000000 82.240000000000000000 +10 1425 92 92.0 NULL NULL NULL NULL +10 1511 76 76.0 31.47 31.47 31.470000000000000000 31.470000000000000000 +10 3433 83 83.0 10.26 10.26 10.260000000000000000 10.260000000000000000 +10 3933 52 52.0 52.19 52.19 52.190000000000000000 52.190000000000000000 +10 4357 17 17.0 88.36 88.36 88.360000000000000000 88.360000000000000000 +10 5863 47 47.0 11.71 11.71 11.710000000000000000 11.710000000000000000 +10 9811 28 28.0 47.85 47.85 47.850000000000000000 47.850000000000000000 +10 13803 66 66.0 82.35 82.35 82.350000000000000000 82.350000000000000000 +10 15447 67 67.0 33.28 33.28 33.280000000000000000 33.280000000000000000 +11 157 84 84.0 64.63 64.63 64.630000000000000000 64.630000000000000000 +11 1315 70 70.0 45.84 45.84 45.840000000000000000 45.840000000000000000 +11 7519 68 68.0 7.16 7.16 7.160000000000000000 7.160000000000000000 +11 7608 66 66.0 8.34 8.34 8.340000000000000000 8.340000000000000000 +11 9901 57 57.0 46.93 46.93 46.930000000000000000 46.930000000000000000 +11 10699 33 33.0 73.77 73.77 73.770000000000000000 73.770000000000000000 +11 11490 NULL NULL NULL NULL NULL NULL +11 11991 38 38.0 3.27 3.27 3.270000000000000000 3.270000000000000000 +11 12438 16 16.0 92.94 92.94 92.940000000000000000 92.940000000000000000 +11 15157 96 96.0 15.52 15.52 15.520000000000000000 15.520000000000000000 +11 15649 33 33.0 66.11 66.11 66.110000000000000000 66.110000000000000000 +11 17226 11 11.0 34.03 34.03 34.030000000000000000 34.030000000000000000 +11 17395 85 85.0 38.04 38.04 38.040000000000000000 38.040000000000000000 +12 373 57 57.0 13.95 13.95 13.950000000000000000 13.950000000000000000 +12 1591 82 82.0 45.84 45.84 45.840000000000000000 45.840000000000000000 +12 4888 56 56.0 75.74 75.74 75.740000000000000000 75.740000000000000000 +12 6148 36 36.0 97.62 97.62 97.620000000000000000 97.620000000000000000 +12 6248 36 36.0 75.17 75.17 75.170000000000000000 75.170000000000000000 +12 9616 66 66.0 99.06 99.06 99.060000000000000000 99.060000000000000000 +12 9788 73 73.0 79.42 79.42 79.420000000000000000 79.420000000000000000 +12 13399 46 46.0 45.27 45.27 45.270000000000000000 45.270000000000000000 +12 14746 26 26.0 58.74 58.74 58.740000000000000000 58.740000000000000000 +12 14944 9 9.0 7.33 7.33 7.330000000000000000 7.330000000000000000 +12 15440 99 99.0 27.09 27.09 27.090000000000000000 27.090000000000000000 +13 868 NULL NULL 62.85 62.85 62.850000000000000000 62.850000000000000000 +13 1760 12 12.0 80.96 80.96 80.960000000000000000 80.960000000000000000 +13 1898 NULL NULL 96.46 96.46 96.460000000000000000 96.460000000000000000 +13 2108 9 9.0 NULL NULL NULL NULL +13 2191 NULL NULL NULL NULL NULL NULL +13 4430 73 73.0 5.86 5.86 5.860000000000000000 5.860000000000000000 +13 5971 80 80.0 72.61 72.61 72.610000000000000000 72.610000000000000000 +13 6085 58 58.0 21.45 21.45 21.450000000000000000 21.450000000000000000 +13 6140 15 15.0 89.9 89.9 89.900000000000000000 89.900000000000000000 +13 6682 80 80.0 32.05 32.05 32.050000000000000000 32.050000000000000000 +13 7640 48 48.0 17.06 17.06 17.060000000000000000 17.060000000000000000 +13 7723 27 27.0 59.09 59.09 59.090000000000000000 59.090000000000000000 +13 10096 12 12.0 17.14 17.14 17.140000000000000000 17.140000000000000000 +13 11758 34 34.0 72.24 72.24 72.240000000000000000 72.240000000000000000 +13 16894 87 87.0 20.99 20.99 20.990000000000000000 20.990000000000000000 +13 17240 20 20.0 93.85 93.85 93.850000000000000000 93.850000000000000000 +14 177 41 41.0 13.05 13.05 13.050000000000000000 13.050000000000000000 +14 769 20 20.0 26.29 26.29 26.290000000000000000 26.290000000000000000 +14 4507 4 4.0 45.45 45.45 45.450000000000000000 45.450000000000000000 +14 10175 19 19.0 39.97 39.97 39.970000000000000000 39.970000000000000000 +14 11549 6 6.0 19.33 19.33 19.330000000000000000 19.330000000000000000 +14 11653 60 60.0 86.94 86.94 86.940000000000000000 86.940000000000000000 +14 11817 81 81.0 60.77 60.77 60.770000000000000000 60.770000000000000000 +14 12587 NULL NULL NULL NULL NULL NULL +14 13069 77 77.0 93.6 93.6 93.600000000000000000 93.600000000000000000 +14 13515 57 57.0 87.32 87.32 87.320000000000000000 87.320000000000000000 +14 13845 17 17.0 52.3 52.3 52.300000000000000000 52.300000000000000000 +14 16741 46 46.0 76.43 76.43 76.430000000000000000 76.430000000000000000 +14 16929 14 14.0 54.76 54.76 54.760000000000000000 54.760000000000000000 +15 4241 21 21.0 89.07 89.07 89.070000000000000000 89.070000000000000000 +15 4505 59 59.0 77.35 77.35 77.350000000000000000 77.350000000000000000 +15 4777 28 28.0 36.86 36.86 36.860000000000000000 36.860000000000000000 +15 7391 98 98.0 53.76 53.76 53.760000000000000000 53.760000000000000000 +15 8336 15 15.0 44.09 44.09 44.090000000000000000 44.090000000000000000 +15 8353 NULL NULL NULL NULL NULL NULL +15 8690 32 32.0 67.37 67.37 67.370000000000000000 67.370000000000000000 +15 8707 21 21.0 48.54 48.54 48.540000000000000000 48.540000000000000000 +15 10361 39 39.0 74.88 74.88 74.880000000000000000 74.880000000000000000 +15 11659 80 80.0 86.23 86.23 86.230000000000000000 86.230000000000000000 +15 13172 25 25.0 47.11 47.11 47.110000000000000000 47.110000000000000000 +15 16619 81 81.0 80.21 80.21 80.210000000000000000 80.210000000000000000 +15 17267 7 7.0 30.61 30.61 30.610000000000000000 30.610000000000000000 +15 17330 82 82.0 67.45 67.45 67.450000000000000000 67.450000000000000000 +15 17564 26 26.0 63.52 63.52 63.520000000000000000 63.520000000000000000 +15 17857 38 38.0 96.35 96.35 96.350000000000000000 96.350000000000000000 +16 457 60 60.0 91.53 91.53 91.530000000000000000 91.530000000000000000 +16 1888 4 4.0 47.64 47.64 47.640000000000000000 47.640000000000000000 +16 4144 94 94.0 19.91 19.91 19.910000000000000000 19.910000000000000000 +16 6008 59 59.0 59.62 59.62 59.620000000000000000 59.620000000000000000 +16 7504 51 51.0 31.35 31.35 31.350000000000000000 31.350000000000000000 +16 8887 35 35.0 59.82 59.82 59.820000000000000000 59.820000000000000000 +16 9769 42 42.0 29.53 29.53 29.530000000000000000 29.530000000000000000 +16 9790 17 17.0 36.95 36.95 36.950000000000000000 36.950000000000000000 +16 9997 94 94.0 64.76 64.76 64.760000000000000000 64.760000000000000000 +16 11168 86 86.0 62.85 62.85 62.850000000000000000 62.850000000000000000 +16 11920 29 29.0 94.31 94.31 94.310000000000000000 94.310000000000000000 +16 16226 13 13.0 31.3 31.3 31.300000000000000000 31.300000000000000000 +16 17246 70 70.0 80.85 80.85 80.850000000000000000 80.850000000000000000 +17 2092 37 37.0 31.71 31.71 31.710000000000000000 31.710000000000000000 +17 4678 34 34.0 32.47 32.47 32.470000000000000000 32.470000000000000000 +17 6811 70 70.0 62.96 62.96 62.960000000000000000 62.960000000000000000 +17 9214 57 57.0 14.2 14.2 14.200000000000000000 14.200000000000000000 +17 10543 54 54.0 57.11 57.11 57.110000000000000000 57.110000000000000000 +17 11203 21 21.0 93.44 93.44 93.440000000000000000 93.440000000000000000 +17 13177 45 45.0 44.18 44.18 44.180000000000000000 44.180000000000000000 +17 13826 32 32.0 58.61 58.61 58.610000000000000000 58.610000000000000000 +17 15781 76 76.0 24.79 24.79 24.790000000000000000 24.790000000000000000 +17 17683 34 34.0 81.48 81.48 81.480000000000000000 81.480000000000000000 +18 2440 40 40.0 15.39 15.39 15.390000000000000000 15.390000000000000000 +18 5251 41 41.0 45.83 45.83 45.830000000000000000 45.830000000000000000 +18 7378 94 94.0 61.01 61.01 61.010000000000000000 61.010000000000000000 +18 8779 9 9.0 75.19 75.19 75.190000000000000000 75.190000000000000000 +18 8884 18 18.0 43.49 43.49 43.490000000000000000 43.490000000000000000 +18 9886 62 62.0 9.59 9.59 9.590000000000000000 9.590000000000000000 +18 11584 76 76.0 4.26 4.26 4.260000000000000000 4.260000000000000000 +18 11890 7 7.0 82.36 82.36 82.360000000000000000 82.360000000000000000 +18 12602 81 81.0 11.32 11.32 11.320000000000000000 11.320000000000000000 +18 12826 93 93.0 82.82 82.82 82.820000000000000000 82.820000000000000000 +18 12860 18 18.0 19.89 19.89 19.890000000000000000 19.890000000000000000 +18 14011 95 95.0 55.01 55.01 55.010000000000000000 55.010000000000000000 +18 14372 76 76.0 89.58 89.58 89.580000000000000000 89.580000000000000000 +18 14377 15 15.0 15.47 15.47 15.470000000000000000 15.470000000000000000 +18 17995 13 13.0 46.79 46.79 46.790000000000000000 46.790000000000000000 +19 1094 48 48.0 19.55 19.55 19.550000000000000000 19.550000000000000000 +19 3133 96 96.0 68.89 68.89 68.890000000000000000 68.890000000000000000 +19 3376 84 84.0 63.07 63.07 63.070000000000000000 63.070000000000000000 +19 4882 84 84.0 41.48 41.48 41.480000000000000000 41.480000000000000000 +19 6772 97 97.0 36.04 36.04 36.040000000000000000 36.040000000000000000 +19 7087 1 1.0 48.67 48.67 48.670000000000000000 48.670000000000000000 +19 7814 29 29.0 61.78 61.78 61.780000000000000000 61.780000000000000000 +19 8662 97 97.0 72.78 72.78 72.780000000000000000 72.780000000000000000 +19 9094 49 49.0 61.82 61.82 61.820000000000000000 61.820000000000000000 +19 9346 39 39.0 84.06 84.06 84.060000000000000000 84.060000000000000000 +19 10558 82 82.0 12.34 12.34 12.340000000000000000 12.340000000000000000 +19 10651 46 46.0 57.69 57.69 57.690000000000000000 57.690000000000000000 +19 11914 59 59.0 88.03 88.03 88.030000000000000000 88.030000000000000000 +19 16330 NULL NULL 79.15 79.15 79.150000000000000000 79.150000000000000000 +19 17539 20 20.0 69.2 69.2 69.200000000000000000 69.200000000000000000 +20 1451 89 89.0 84.34 84.34 84.340000000000000000 84.340000000000000000 +20 2618 4 4.0 69.47 69.47 69.470000000000000000 69.470000000000000000 +20 5312 9 9.0 29.45 29.45 29.450000000000000000 29.450000000000000000 +20 5425 15 15.0 28.19 28.19 28.190000000000000000 28.190000000000000000 +20 5483 8 8.0 30.74 30.74 30.740000000000000000 30.740000000000000000 +20 6026 21 21.0 80.56 80.56 80.560000000000000000 80.560000000000000000 +20 7207 90 90.0 83.12 83.12 83.120000000000000000 83.120000000000000000 +20 8714 NULL NULL 8.15 8.15 8.150000000000000000 8.150000000000000000 +20 9086 4 4.0 98.99 98.99 98.990000000000000000 98.990000000000000000 +20 9800 32 32.0 18.09 18.09 18.090000000000000000 18.090000000000000000 +20 13601 17 17.0 1.4 1.4 1.400000000000000000 1.400000000000000000 +20 14935 NULL NULL NULL NULL NULL NULL +20 15131 85 85.0 42.56 42.56 42.560000000000000000 42.560000000000000000 +21 230 48 48.0 13.37 13.37 13.370000000000000000 13.370000000000000000 +21 1810 59 59.0 66.37 66.37 66.370000000000000000 66.370000000000000000 +21 2870 50 50.0 91.94 91.94 91.940000000000000000 91.940000000000000000 +21 5170 45 45.0 90.0 90.0 90.000000000000000000 90.000000000000000000 +21 5998 51 51.0 9.41 9.41 9.410000000000000000 9.410000000000000000 +21 6476 49 49.0 20.29 20.29 20.290000000000000000 20.290000000000000000 +21 9187 14 14.0 35.49 35.49 35.490000000000000000 35.490000000000000000 +21 12266 47 47.0 11.55 11.55 11.550000000000000000 11.550000000000000000 +21 14368 18 18.0 51.29 51.29 51.290000000000000000 51.290000000000000000 +21 14396 88 88.0 45.26 45.26 45.260000000000000000 45.260000000000000000 +22 9985 70 70.0 21.46 21.46 21.460000000000000000 21.460000000000000000 +22 10474 31 31.0 45.65 45.65 45.650000000000000000 45.650000000000000000 +22 11599 66 66.0 5.01 5.01 5.010000000000000000 5.010000000000000000 +22 12415 10 10.0 38.97 38.97 38.970000000000000000 38.970000000000000000 +22 15310 15 15.0 82.24 82.24 82.240000000000000000 82.240000000000000000 +22 16396 85 85.0 86.46 86.46 86.460000000000000000 86.460000000000000000 +22 16922 88 88.0 28.0 28.0 28.000000000000000000 28.000000000000000000 +22 17392 14 14.0 51.86 51.86 51.860000000000000000 51.860000000000000000 +22 17660 70 70.0 95.56 95.56 95.560000000000000000 95.560000000000000000 +23 319 86 86.0 66.36 66.36 66.360000000000000000 66.360000000000000000 +23 7242 37 37.0 54.82 54.82 54.820000000000000000 54.820000000000000000 +23 8181 13 13.0 4.63 4.63 4.630000000000000000 4.630000000000000000 +23 8413 1 1.0 14.2 14.2 14.200000000000000000 14.200000000000000000 +23 9093 38 38.0 80.2 80.2 80.200000000000000000 80.200000000000000000 +23 9097 81 81.0 72.51 72.51 72.510000000000000000 72.510000000000000000 +23 11220 91 91.0 71.3 71.3 71.300000000000000000 71.300000000000000000 +23 11257 64 64.0 29.95 29.95 29.950000000000000000 29.950000000000000000 +23 12397 80 80.0 78.73 78.73 78.730000000000000000 78.730000000000000000 +23 15403 96 96.0 51.96 51.96 51.960000000000000000 51.960000000000000000 +23 17631 16 16.0 22.06 22.06 22.060000000000000000 22.060000000000000000 +24 407 53 53.0 98.05 98.05 98.050000000000000000 98.050000000000000000 +24 1389 72 72.0 60.01 60.01 60.010000000000000000 60.010000000000000000 +24 1795 21 21.0 76.67 76.67 76.670000000000000000 76.670000000000000000 +24 2497 85 85.0 57.93 57.93 57.930000000000000000 57.930000000000000000 +24 3103 73 73.0 44.96 44.96 44.960000000000000000 44.960000000000000000 +24 4425 57 57.0 29.31 29.31 29.310000000000000000 29.310000000000000000 +24 4749 28 28.0 18.17 18.17 18.170000000000000000 18.170000000000000000 +24 4873 41 41.0 40.34 40.34 40.340000000000000000 40.340000000000000000 +24 5653 92 92.0 64.99 64.99 64.990000000000000000 64.990000000000000000 +24 6043 1 1.0 33.41 33.41 33.410000000000000000 33.410000000000000000 +24 6751 82 82.0 7.48 7.48 7.480000000000000000 7.480000000000000000 +24 7375 97 97.0 78.55 78.55 78.550000000000000000 78.550000000000000000 +24 10265 93 93.0 12.03 12.03 12.030000000000000000 12.030000000000000000 +24 11551 48 48.0 30.8 30.8 30.800000000000000000 30.800000000000000000 +24 13303 97 97.0 94.48 94.48 94.480000000000000000 94.480000000000000000 +24 16483 89 89.0 13.84 13.84 13.840000000000000000 13.840000000000000000 +25 1333 55 55.0 30.82 30.82 30.820000000000000000 30.820000000000000000 +25 2150 100 100.0 67.24 67.24 67.240000000000000000 67.240000000000000000 +25 2608 76 76.0 87.75 87.75 87.750000000000000000 87.750000000000000000 +25 3454 100 100.0 1.61 1.61 1.610000000000000000 1.610000000000000000 +25 4880 29 29.0 15.35 15.35 15.350000000000000000 15.350000000000000000 +25 5954 34 34.0 76.57 76.57 76.570000000000000000 76.570000000000000000 +25 6955 40 40.0 87.12 87.12 87.120000000000000000 87.120000000000000000 +25 7874 65 65.0 2.75 2.75 2.750000000000000000 2.750000000000000000 +25 9472 48 48.0 4.97 4.97 4.970000000000000000 4.970000000000000000 +25 10159 24 24.0 76.64 76.64 76.640000000000000000 76.640000000000000000 +25 14488 26 26.0 68.17 68.17 68.170000000000000000 68.170000000000000000 +25 14635 68 68.0 45.79 45.79 45.790000000000000000 45.790000000000000000 +25 17000 40 40.0 89.34 89.34 89.340000000000000000 89.340000000000000000 +25 17752 55 55.0 11.49 11.49 11.490000000000000000 11.490000000000000000 +26 1989 26 26.0 83.31 83.31 83.310000000000000000 83.310000000000000000 +26 5053 4 4.0 19.63 19.63 19.630000000000000000 19.630000000000000000 +26 5385 97 97.0 51.89 51.89 51.890000000000000000 51.890000000000000000 +26 5721 81 81.0 74.96 74.96 74.960000000000000000 74.960000000000000000 +26 6647 64 64.0 57.04 57.04 57.040000000000000000 57.040000000000000000 +26 7337 45 45.0 37.59 37.59 37.590000000000000000 37.590000000000000000 +26 9679 18 18.0 77.54 77.54 77.540000000000000000 77.540000000000000000 +26 11895 77 77.0 36.85 36.85 36.850000000000000000 36.850000000000000000 +26 12851 56 56.0 14.02 14.02 14.020000000000000000 14.020000000000000000 +26 15039 34 34.0 22.65 22.65 22.650000000000000000 22.650000000000000000 +27 1305 44 44.0 8.35 8.35 8.350000000000000000 8.350000000000000000 +27 2137 96 96.0 3.07 3.07 3.070000000000000000 3.070000000000000000 +27 2671 92 92.0 4.35 4.35 4.350000000000000000 4.350000000000000000 +27 5831 61 61.0 8.79 8.79 8.790000000000000000 8.790000000000000000 +27 7139 59 59.0 6.17 6.17 6.170000000000000000 6.170000000000000000 +27 8167 28 28.0 38.83 38.83 38.830000000000000000 38.830000000000000000 +27 10757 15 15.0 8.7 8.7 8.700000000000000000 8.700000000000000000 +27 11441 15 15.0 14.45 14.45 14.450000000000000000 14.450000000000000000 +27 11509 65 65.0 80.34 80.34 80.340000000000000000 80.340000000000000000 +27 12237 89 89.0 73.9 73.9 73.900000000000000000 73.900000000000000000 +27 12749 31 31.0 80.27 80.27 80.270000000000000000 80.270000000000000000 +27 13885 66 66.0 40.62 40.62 40.620000000000000000 40.620000000000000000 +27 15025 26 26.0 35.56 35.56 35.560000000000000000 35.560000000000000000 +27 16029 59 59.0 2.11 2.11 2.110000000000000000 2.110000000000000000 +27 16419 65 65.0 80.1 80.1 80.100000000000000000 80.100000000000000000 +27 16767 60 60.0 68.33 68.33 68.330000000000000000 68.330000000000000000 +28 1807 98 98.0 78.91 78.91 78.910000000000000000 78.910000000000000000 +28 2817 8 8.0 98.75 98.75 98.750000000000000000 98.750000000000000000 +28 2967 29 29.0 47.87 47.87 47.870000000000000000 47.870000000000000000 +28 4483 78 78.0 73.9 73.9 73.900000000000000000 73.900000000000000000 +28 5437 15 15.0 7.49 7.49 7.490000000000000000 7.490000000000000000 +28 6411 3 3.0 67.26 67.26 67.260000000000000000 67.260000000000000000 +28 7965 93 93.0 77.74 77.74 77.740000000000000000 77.740000000000000000 +28 8043 58 58.0 60.26 60.26 60.260000000000000000 60.260000000000000000 +28 8407 14 14.0 95.01 95.01 95.010000000000000000 95.010000000000000000 +28 10295 13 13.0 31.83 31.83 31.830000000000000000 31.830000000000000000 +29 20 18 18.0 66.26 66.26 66.260000000000000000 66.260000000000000000 +29 1363 75 75.0 NULL NULL NULL NULL +29 2930 23 23.0 64.78 64.78 64.780000000000000000 64.780000000000000000 +29 3740 5 5.0 90.13 90.13 90.130000000000000000 90.130000000000000000 +29 7654 20 20.0 98.14 98.14 98.140000000000000000 98.140000000000000000 +29 9458 33 33.0 52.33 52.33 52.330000000000000000 52.330000000000000000 +29 10795 33 33.0 68.24 68.24 68.240000000000000000 68.240000000000000000 +29 12068 37 37.0 80.75 80.75 80.750000000000000000 80.750000000000000000 +29 12223 59 59.0 12.89 12.89 12.890000000000000000 12.890000000000000000 +29 13340 21 21.0 40.5 40.5 40.500000000000000000 40.500000000000000000 +29 13693 NULL NULL 95.63 95.63 95.630000000000000000 95.630000000000000000 +29 15085 40 40.0 NULL NULL NULL NULL +29 15626 NULL NULL 17.61 17.61 17.610000000000000000 17.610000000000000000 +29 15782 53 53.0 57.11 57.11 57.110000000000000000 57.110000000000000000 +30 217 91 91.0 52.03 52.03 52.030000000000000000 52.030000000000000000 +30 1951 59 59.0 17.14 17.14 17.140000000000000000 17.140000000000000000 +30 3238 16 16.0 9.84 9.84 9.840000000000000000 9.840000000000000000 +30 3506 15 15.0 16.31 16.31 16.310000000000000000 16.310000000000000000 +30 3928 87 87.0 27.01 27.01 27.010000000000000000 27.010000000000000000 +30 5431 77 77.0 52.37 52.37 52.370000000000000000 52.370000000000000000 +30 6752 69 69.0 40.8 40.8 40.800000000000000000 40.800000000000000000 +30 7870 7 7.0 4.51 4.51 4.510000000000000000 4.510000000000000000 +30 8666 21 21.0 64.0 64.0 64.000000000000000000 64.000000000000000000 +30 12572 33 33.0 61.96 61.96 61.960000000000000000 61.960000000000000000 +30 12670 20 20.0 6.44 6.44 6.440000000000000000 6.440000000000000000 +30 13579 75 75.0 62.71 62.71 62.710000000000000000 62.710000000000000000 +30 14848 62 62.0 64.03 64.03 64.030000000000000000 64.030000000000000000 +30 17348 62 62.0 88.74 88.74 88.740000000000000000 88.740000000000000000 +30 17875 78 78.0 2.91 2.91 2.910000000000000000 2.910000000000000000 +31 913 54 54.0 79.11 79.11 79.110000000000000000 79.110000000000000000 +31 4963 67 67.0 56.37 56.37 56.370000000000000000 56.370000000000000000 +31 6617 11 11.0 86.78 86.78 86.780000000000000000 86.780000000000000000 +31 6917 4 4.0 49.76 49.76 49.760000000000000000 49.760000000000000000 +31 7513 82 82.0 44.95 44.95 44.950000000000000000 44.950000000000000000 +31 11739 95 95.0 6.99 6.99 6.990000000000000000 6.990000000000000000 +31 14575 97 97.0 59.9 59.9 59.900000000000000000 59.900000000000000000 +31 14727 41 41.0 48.1 48.1 48.100000000000000000 48.100000000000000000 +31 15341 31 31.0 16.15 16.15 16.150000000000000000 16.150000000000000000 +31 15411 53 53.0 47.64 47.64 47.640000000000000000 47.640000000000000000 +31 16251 51 51.0 91.49 91.49 91.490000000000000000 91.490000000000000000 +32 1115 61 61.0 97.03 97.03 97.030000000000000000 97.030000000000000000 +32 2095 34 34.0 89.33 89.33 89.330000000000000000 89.330000000000000000 +32 2887 8 8.0 48.71 48.71 48.710000000000000000 48.710000000000000000 +32 4339 6 6.0 88.27 88.27 88.270000000000000000 88.270000000000000000 +32 4537 22 22.0 65.72 65.72 65.720000000000000000 65.720000000000000000 +32 4808 NULL NULL 57.01 57.01 57.010000000000000000 57.010000000000000000 +32 5798 87 87.0 46.23 46.23 46.230000000000000000 46.230000000000000000 +32 7547 24 24.0 43.33 43.33 43.330000000000000000 43.330000000000000000 +32 9683 26 26.0 NULL NULL NULL NULL +32 11005 46 46.0 51.48 51.48 51.480000000000000000 51.480000000000000000 +32 11348 41 41.0 55.14 55.14 55.140000000000000000 55.140000000000000000 +32 12134 21 21.0 51.01 51.01 51.010000000000000000 51.010000000000000000 +32 15001 57 57.0 30.07 30.07 30.070000000000000000 30.070000000000000000 +32 15644 34 34.0 80.54 80.54 80.540000000000000000 80.540000000000000000 +32 16421 74 74.0 89.89 89.89 89.890000000000000000 89.890000000000000000 +32 17659 51 51.0 23.88 23.88 23.880000000000000000 23.880000000000000000 +33 4798 27 27.0 28.56 28.56 28.560000000000000000 28.560000000000000000 +33 7300 3 3.0 3.13 3.13 3.130000000000000000 3.130000000000000000 +33 9649 36 36.0 18.91 18.91 18.910000000000000000 18.910000000000000000 +33 10376 21 21.0 55.09 55.09 55.090000000000000000 55.090000000000000000 +33 11119 92 92.0 3.49 3.49 3.490000000000000000 3.490000000000000000 +33 11756 26 26.0 58.87 58.87 58.870000000000000000 58.870000000000000000 +33 12643 89 89.0 35.74 35.74 35.740000000000000000 35.740000000000000000 +33 12760 54 54.0 48.97 48.97 48.970000000000000000 48.970000000000000000 +33 12964 80 80.0 83.86 83.86 83.860000000000000000 83.860000000000000000 +33 14125 66 66.0 44.03 44.03 44.030000000000000000 44.030000000000000000 +33 14158 82 82.0 48.07 48.07 48.070000000000000000 48.070000000000000000 +33 14692 93 93.0 56.78 56.78 56.780000000000000000 56.780000000000000000 +33 15478 22 22.0 95.96 95.96 95.960000000000000000 95.960000000000000000 +34 1526 91 91.0 78.12 78.12 78.120000000000000000 78.120000000000000000 +34 1717 53 53.0 99.68 99.68 99.680000000000000000 99.680000000000000000 +34 2312 6 6.0 51.4 51.4 51.400000000000000000 51.400000000000000000 +34 4118 88 88.0 38.38 38.38 38.380000000000000000 38.380000000000000000 +34 5197 63 63.0 13.5 13.5 13.500000000000000000 13.500000000000000000 +34 5449 9 9.0 21.24 21.24 21.240000000000000000 21.240000000000000000 +34 6193 61 61.0 54.55 54.55 54.550000000000000000 54.550000000000000000 +34 9325 3 3.0 92.35 92.35 92.350000000000000000 92.350000000000000000 +34 9766 83 83.0 68.57 68.57 68.570000000000000000 68.570000000000000000 +34 12016 42 42.0 42.44 42.44 42.440000000000000000 42.440000000000000000 +34 12290 53 53.0 88.61 88.61 88.610000000000000000 88.610000000000000000 +34 12512 60 60.0 40.48 40.48 40.480000000000000000 40.480000000000000000 +34 13814 20 20.0 22.82 22.82 22.820000000000000000 22.820000000000000000 +34 16324 30 30.0 37.27 37.27 37.270000000000000000 37.270000000000000000 +35 411 51 51.0 NULL NULL NULL NULL +35 2377 52 52.0 98.03 98.03 98.030000000000000000 98.030000000000000000 +35 3667 97 97.0 59.31 59.31 59.310000000000000000 59.310000000000000000 +35 4325 56 56.0 67.43 67.43 67.430000000000000000 67.430000000000000000 +35 5179 83 83.0 90.54 90.54 90.540000000000000000 90.540000000000000000 +35 11635 87 87.0 92.02 92.02 92.020000000000000000 92.020000000000000000 +35 11661 81 81.0 NULL NULL NULL NULL +35 14239 55 55.0 8.27 8.27 8.270000000000000000 8.270000000000000000 +35 15619 45 45.0 90.28 90.28 90.280000000000000000 90.280000000000000000 +35 15757 9 9.0 14.83 14.83 14.830000000000000000 14.830000000000000000 +35 17341 92 92.0 59.48 59.48 59.480000000000000000 59.480000000000000000 +35 17365 65 65.0 76.2 76.2 76.200000000000000000 76.200000000000000000 +35 17451 7 7.0 45.66 45.66 45.660000000000000000 45.660000000000000000 +36 1115 80 80.0 11.13 11.13 11.130000000000000000 11.130000000000000000 +36 2095 43 43.0 91.17 91.17 91.170000000000000000 91.170000000000000000 +36 2887 31 31.0 24.53 24.53 24.530000000000000000 24.530000000000000000 +36 7547 46 46.0 8.04 8.04 8.040000000000000000 8.040000000000000000 +36 11005 49 49.0 70.6 70.6 70.600000000000000000 70.600000000000000000 +36 11349 80 80.0 58.17 58.17 58.170000000000000000 58.170000000000000000 +36 15001 54 54.0 16.24 16.24 16.240000000000000000 16.240000000000000000 +36 15645 23 23.0 32.35 32.35 32.350000000000000000 32.350000000000000000 +36 16421 25 25.0 69.67 69.67 69.670000000000000000 69.670000000000000000 +36 17561 16 16.0 82.46 82.46 82.460000000000000000 82.460000000000000000 +36 17659 91 91.0 44.83 44.83 44.830000000000000000 44.830000000000000000 +37 2997 94 94.0 85.67 85.67 85.670000000000000000 85.670000000000000000 +37 7283 87 87.0 54.25 54.25 54.250000000000000000 54.250000000000000000 +37 10715 52 52.0 89.22 89.22 89.220000000000000000 89.220000000000000000 +37 10929 88 88.0 65.45 65.45 65.450000000000000000 65.450000000000000000 +37 13171 6 6.0 84.14 84.14 84.140000000000000000 84.140000000000000000 +37 15337 62 62.0 16.64 16.64 16.640000000000000000 16.640000000000000000 +37 16971 12 12.0 53.97 53.97 53.970000000000000000 53.970000000000000000 +37 17125 NULL NULL NULL NULL NULL NULL +38 757 2 2.0 NULL NULL NULL NULL +38 2164 17 17.0 72.04 72.04 72.040000000000000000 72.040000000000000000 +38 3439 84 84.0 11.71 11.71 11.710000000000000000 11.710000000000000000 +38 4154 35 35.0 10.28 10.28 10.280000000000000000 10.280000000000000000 +38 5113 73 73.0 50.59 50.59 50.590000000000000000 50.590000000000000000 +38 6220 98 98.0 14.54 14.54 14.540000000000000000 14.540000000000000000 +38 7018 15 15.0 69.78 69.78 69.780000000000000000 69.780000000000000000 +38 7784 56 56.0 31.89 31.89 31.890000000000000000 31.890000000000000000 +38 8870 15 15.0 46.69 46.69 46.690000000000000000 46.690000000000000000 +38 9710 7 7.0 82.77 82.77 82.770000000000000000 82.770000000000000000 +38 10441 62 62.0 80.37 80.37 80.370000000000000000 80.370000000000000000 +38 15698 57 57.0 11.4 11.4 11.400000000000000000 11.400000000000000000 +39 386 89 89.0 28.08 28.08 28.080000000000000000 28.080000000000000000 +39 1598 64 64.0 44.63 44.63 44.630000000000000000 44.630000000000000000 +39 3476 73 73.0 80.57 80.57 80.570000000000000000 80.570000000000000000 +39 3943 64 64.0 59.68 59.68 59.680000000000000000 59.680000000000000000 +39 4190 86 86.0 35.56 35.56 35.560000000000000000 35.560000000000000000 +39 4957 24 24.0 16.1 16.1 16.100000000000000000 16.100000000000000000 +39 5393 98 98.0 58.75 58.75 58.750000000000000000 58.750000000000000000 +39 7097 78 78.0 33.1 33.1 33.100000000000000000 33.100000000000000000 +39 7118 67 67.0 68.99 68.99 68.990000000000000000 68.990000000000000000 +39 7604 49 49.0 46.49 46.49 46.490000000000000000 46.490000000000000000 +39 7697 24 24.0 44.89 44.89 44.890000000000000000 44.890000000000000000 +39 8078 54 54.0 73.6 73.6 73.600000000000000000 73.600000000000000000 +39 8411 96 96.0 35.69 35.69 35.690000000000000000 35.690000000000000000 +39 15491 54 54.0 3.2 3.2 3.200000000000000000 3.200000000000000000 +39 15625 17 17.0 96.62 96.62 96.620000000000000000 96.620000000000000000 +40 2854 71 71.0 10.62 10.62 10.620000000000000000 10.620000000000000000 +40 3490 65 65.0 41.24 41.24 41.240000000000000000 41.240000000000000000 +40 3985 63 63.0 22.94 22.94 22.940000000000000000 22.940000000000000000 +40 5098 35 35.0 33.91 33.91 33.910000000000000000 33.910000000000000000 +40 5318 87 87.0 32.66 32.66 32.660000000000000000 32.660000000000000000 +40 10094 80 80.0 8.63 8.63 8.630000000000000000 8.630000000000000000 +40 10912 23 23.0 2.46 2.46 2.460000000000000000 2.460000000000000000 +40 12050 NULL NULL 38.12 38.12 38.120000000000000000 38.120000000000000000 +40 13658 53 53.0 56.42 56.42 56.420000000000000000 56.420000000000000000 +40 16976 3 3.0 20.7 20.7 20.700000000000000000 20.700000000000000000 +41 10 50 50.0 54.36 54.36 54.360000000000000000 54.360000000000000000 +41 64 29 29.0 27.18 27.18 27.180000000000000000 27.180000000000000000 +41 3380 88 88.0 14.11 14.11 14.110000000000000000 14.110000000000000000 +41 5566 11 11.0 50.45 50.45 50.450000000000000000 50.450000000000000000 +41 6310 90 90.0 60.1 60.1 60.100000000000000000 60.100000000000000000 +41 7402 69 69.0 57.23 57.23 57.230000000000000000 57.230000000000000000 +41 7603 94 94.0 6.12 6.12 6.120000000000000000 6.120000000000000000 +41 9322 8 8.0 59.4 59.4 59.400000000000000000 59.400000000000000000 +41 10915 81 81.0 91.63 91.63 91.630000000000000000 91.630000000000000000 +41 14788 15 15.0 90.04 90.04 90.040000000000000000 90.040000000000000000 +41 15242 87 87.0 48.25 48.25 48.250000000000000000 48.250000000000000000 +41 15328 46 46.0 84.03 84.03 84.030000000000000000 84.030000000000000000 +41 16514 20 20.0 5.05 5.05 5.050000000000000000 5.050000000000000000 +42 619 69 69.0 56.85 56.85 56.850000000000000000 56.850000000000000000 +42 976 100 100.0 12.59 12.59 12.590000000000000000 12.590000000000000000 +42 1436 94 94.0 54.21 54.21 54.210000000000000000 54.210000000000000000 +42 2314 74 74.0 24.46 24.46 24.460000000000000000 24.460000000000000000 +42 2392 14 14.0 49.48 49.48 49.480000000000000000 49.480000000000000000 +42 2602 30 30.0 55.77 55.77 55.770000000000000000 55.770000000000000000 +42 3346 74 74.0 29.72 29.72 29.720000000000000000 29.720000000000000000 +42 3613 30 30.0 56.33 56.33 56.330000000000000000 56.330000000000000000 +42 6058 30 30.0 81.1 81.1 81.100000000000000000 81.100000000000000000 +42 6134 92 92.0 18.91 18.91 18.910000000000000000 18.910000000000000000 +42 8462 23 23.0 27.88 27.88 27.880000000000000000 27.880000000000000000 +42 9740 52 52.0 52.46 52.46 52.460000000000000000 52.460000000000000000 +42 10016 57 57.0 12.47 12.47 12.470000000000000000 12.470000000000000000 +42 10471 19 19.0 42.67 42.67 42.670000000000000000 42.670000000000000000 +42 12550 41 41.0 17.09 17.09 17.090000000000000000 17.090000000000000000 +42 15002 41 41.0 58.33 58.33 58.330000000000000000 58.330000000000000000 +43 2923 16 16.0 82.12 82.12 82.120000000000000000 82.120000000000000000 +43 3344 22 22.0 88.77 88.77 88.770000000000000000 88.770000000000000000 +43 3911 26 26.0 21.75 21.75 21.750000000000000000 21.750000000000000000 +43 4364 77 77.0 82.92 82.92 82.920000000000000000 82.920000000000000000 +43 4691 41 41.0 2.24 2.24 2.240000000000000000 2.240000000000000000 +43 5773 85 85.0 66.42 66.42 66.420000000000000000 66.420000000000000000 +43 5852 16 16.0 81.99 81.99 81.990000000000000000 81.990000000000000000 +43 11771 30 30.0 41.13 41.13 41.130000000000000000 41.130000000000000000 +43 14669 97 97.0 52.94 52.94 52.940000000000000000 52.940000000000000000 +44 2351 56 56.0 55.53 55.53 55.530000000000000000 55.530000000000000000 +44 2623 18 18.0 39.17 39.17 39.170000000000000000 39.170000000000000000 +44 7303 14 14.0 36.13 36.13 36.130000000000000000 36.130000000000000000 +44 7527 67 67.0 90.05 90.05 90.050000000000000000 90.050000000000000000 +44 9059 68 68.0 30.11 30.11 30.110000000000000000 30.110000000000000000 +44 11707 83 83.0 85.49 85.49 85.490000000000000000 85.490000000000000000 +44 12341 20 20.0 82.28 82.28 82.280000000000000000 82.280000000000000000 +44 13331 98 98.0 3.53 3.53 3.530000000000000000 3.530000000000000000 +44 13449 45 45.0 50.83 50.83 50.830000000000000000 50.830000000000000000 +44 14149 80 80.0 18.83 18.83 18.830000000000000000 18.830000000000000000 +44 15803 81 81.0 43.81 43.81 43.810000000000000000 43.810000000000000000 +44 16491 56 56.0 32.28 32.28 32.280000000000000000 32.280000000000000000 +44 16837 92 92.0 30.11 30.11 30.110000000000000000 30.110000000000000000 +44 16909 61 61.0 92.15 92.15 92.150000000000000000 92.150000000000000000 +45 811 62 62.0 23.41 23.41 23.410000000000000000 23.410000000000000000 +45 1479 49 49.0 5.01 5.01 5.010000000000000000 5.010000000000000000 +45 3265 98 98.0 27.12 27.12 27.120000000000000000 27.120000000000000000 +45 5309 18 18.0 51.16 51.16 51.160000000000000000 51.160000000000000000 +45 7363 87 87.0 85.95 85.95 85.950000000000000000 85.950000000000000000 +45 10115 68 68.0 38.09 38.09 38.090000000000000000 38.090000000000000000 +45 11095 40 40.0 52.97 52.97 52.970000000000000000 52.970000000000000000 +45 13133 46 46.0 85.87 85.87 85.870000000000000000 85.870000000000000000 +45 16349 6 6.0 94.59 94.59 94.590000000000000000 94.590000000000000000 +46 1960 12 12.0 53.47 53.47 53.470000000000000000 53.470000000000000000 +46 3010 67 67.0 66.87 66.87 66.870000000000000000 66.870000000000000000 +46 7040 33 33.0 90.87 90.87 90.870000000000000000 90.870000000000000000 +46 8065 NULL NULL 43.04 43.04 43.040000000000000000 43.040000000000000000 +46 11426 72 72.0 53.81 53.81 53.810000000000000000 53.810000000000000000 +46 13042 58 58.0 41.38 41.38 41.380000000000000000 41.380000000000000000 +46 15595 32 32.0 29.12 29.12 29.120000000000000000 29.120000000000000000 +46 16540 30 30.0 54.36 54.36 54.360000000000000000 54.360000000000000000 +46 17150 57 57.0 71.68 71.68 71.680000000000000000 71.680000000000000000 +46 17384 13 13.0 93.68 93.68 93.680000000000000000 93.680000000000000000 +47 254 NULL NULL NULL NULL NULL NULL +47 481 30 30.0 36.51 36.51 36.510000000000000000 36.510000000000000000 +47 1132 66 66.0 53.46 53.46 53.460000000000000000 53.460000000000000000 +47 1916 71 71.0 47.62 47.62 47.620000000000000000 47.620000000000000000 +47 3085 51 51.0 63.55 63.55 63.550000000000000000 63.550000000000000000 +47 3202 7 7.0 26.06 26.06 26.060000000000000000 26.060000000000000000 +47 3878 NULL NULL NULL NULL NULL NULL +47 4774 11 11.0 63.71 63.71 63.710000000000000000 63.710000000000000000 +47 5008 82 82.0 1.76 1.76 1.760000000000000000 1.760000000000000000 +47 5305 NULL NULL 84.7 84.7 84.700000000000000000 84.700000000000000000 +47 5468 7 7.0 5.03 5.03 5.030000000000000000 5.030000000000000000 +47 7214 1 1.0 12.8 12.8 12.800000000000000000 12.800000000000000000 +47 9770 33 33.0 69.12 69.12 69.120000000000000000 69.120000000000000000 +47 13246 47 47.0 11.71 11.71 11.710000000000000000 11.710000000000000000 +47 13477 10 10.0 78.83 78.83 78.830000000000000000 78.830000000000000000 +48 1761 22 22.0 55.73 55.73 55.730000000000000000 55.730000000000000000 +48 2820 4 4.0 6.46 6.46 6.460000000000000000 6.460000000000000000 +48 2829 65 65.0 22.1 22.1 22.100000000000000000 22.100000000000000000 +48 4431 39 39.0 97.07 97.07 97.070000000000000000 97.070000000000000000 +48 5971 29 29.0 40.46 40.46 40.460000000000000000 40.460000000000000000 +48 6085 1 1.0 58.13 58.13 58.130000000000000000 58.130000000000000000 +48 6684 44 44.0 20.22 20.22 20.220000000000000000 20.220000000000000000 +48 9199 88 88.0 37.89 37.89 37.890000000000000000 37.890000000000000000 +48 11259 NULL NULL NULL NULL NULL NULL +48 12468 62 62.0 43.72 43.72 43.720000000000000000 43.720000000000000000 +48 13153 74 74.0 34.26 34.26 34.260000000000000000 34.260000000000000000 +48 17799 17 17.0 80.36 80.36 80.360000000000000000 80.360000000000000000 +49 749 60 60.0 42.11 42.11 42.110000000000000000 42.110000000000000000 +49 2135 4 4.0 15.8 15.8 15.800000000000000000 15.800000000000000000 +49 5342 69 69.0 46.41 46.41 46.410000000000000000 46.410000000000000000 +49 5852 47 47.0 74.9 74.9 74.900000000000000000 74.900000000000000000 +49 6805 40 40.0 12.9 12.9 12.900000000000000000 12.900000000000000000 +49 7141 94 94.0 50.5 50.5 50.500000000000000000 50.500000000000000000 +49 9049 68 68.0 75.38 75.38 75.380000000000000000 75.380000000000000000 +49 9553 71 71.0 29.28 29.28 29.280000000000000000 29.280000000000000000 +49 12737 48 48.0 2.17 2.17 2.170000000000000000 2.170000000000000000 +49 15155 84 84.0 4.4 4.4 4.400000000000000000 4.400000000000000000 +49 16361 4 4.0 79.85 79.85 79.850000000000000000 79.850000000000000000 +50 1280 69 69.0 8.66 8.66 8.660000000000000000 8.660000000000000000 +50 1312 30 30.0 25.84 25.84 25.840000000000000000 25.840000000000000000 +50 1909 53 53.0 56.01 56.01 56.010000000000000000 56.010000000000000000 +50 1984 40 40.0 8.81 8.81 8.810000000000000000 8.810000000000000000 +50 3097 64 64.0 33.17 33.17 33.170000000000000000 33.170000000000000000 +50 5023 NULL NULL 16.24 16.24 16.240000000000000000 16.240000000000000000 +50 7135 69 69.0 12.68 12.68 12.680000000000000000 12.680000000000000000 +50 16081 82 82.0 99.55 99.55 99.550000000000000000 99.550000000000000000 +51 422 21 21.0 69.89 69.89 69.890000000000000000 69.890000000000000000 +51 3091 28 28.0 92.87 92.87 92.870000000000000000 92.870000000000000000 +51 4687 6 6.0 93.02 93.02 93.020000000000000000 93.020000000000000000 +51 5029 12 12.0 34.53 34.53 34.530000000000000000 34.530000000000000000 +51 5059 51 51.0 48.54 48.54 48.540000000000000000 48.540000000000000000 +51 6565 33 33.0 32.44 32.44 32.440000000000000000 32.440000000000000000 +51 8384 79 79.0 15.35 15.35 15.350000000000000000 15.350000000000000000 +51 9311 90 90.0 39.48 39.48 39.480000000000000000 39.480000000000000000 +51 10133 54 54.0 46.71 46.71 46.710000000000000000 46.710000000000000000 +51 11234 NULL NULL NULL NULL NULL NULL +51 12625 53 53.0 97.27 97.27 97.270000000000000000 97.270000000000000000 +51 13199 97 97.0 99.32 99.32 99.320000000000000000 99.320000000000000000 +51 17483 22 22.0 31.99 31.99 31.990000000000000000 31.990000000000000000 +51 17705 66 66.0 46.11 46.11 46.110000000000000000 46.110000000000000000 +52 2420 90 90.0 22.31 22.31 22.310000000000000000 22.310000000000000000 +52 3334 73 73.0 29.2 29.2 29.200000000000000000 29.200000000000000000 +52 6098 NULL NULL 4.83 4.83 4.830000000000000000 4.830000000000000000 +52 7606 45 45.0 42.51 42.51 42.510000000000000000 42.510000000000000000 +52 11488 76 76.0 78.68 78.68 78.680000000000000000 78.680000000000000000 +52 15649 29 29.0 22.86 22.86 22.860000000000000000 22.860000000000000000 +52 16646 48 48.0 95.82 95.82 95.820000000000000000 95.820000000000000000 +52 17402 91 91.0 81.94 81.94 81.940000000000000000 81.940000000000000000 +52 17456 37 37.0 7.93 7.93 7.930000000000000000 7.930000000000000000 +53 1114 40 40.0 28.34 28.34 28.340000000000000000 28.340000000000000000 +53 2095 62 62.0 23.98 23.98 23.980000000000000000 23.980000000000000000 +53 2786 70 70.0 76.55 76.55 76.550000000000000000 76.550000000000000000 +53 2887 39 39.0 66.68 66.68 66.680000000000000000 66.680000000000000000 +53 7546 58 58.0 73.79 73.79 73.790000000000000000 73.790000000000000000 +53 11348 38 38.0 5.54 5.54 5.540000000000000000 5.540000000000000000 +53 13220 76 76.0 27.93 27.93 27.930000000000000000 27.930000000000000000 +53 13795 38 38.0 93.96 93.96 93.960000000000000000 93.960000000000000000 +53 15991 37 37.0 77.75 77.75 77.750000000000000000 77.750000000000000000 +53 16420 14 14.0 36.72 36.72 36.720000000000000000 36.720000000000000000 +53 16648 79 79.0 55.29 55.29 55.290000000000000000 55.290000000000000000 +53 17296 43 43.0 21.4 21.4 21.400000000000000000 21.400000000000000000 +53 17560 15 15.0 46.39 46.39 46.390000000000000000 46.390000000000000000 +54 702 40 40.0 16.76 16.76 16.760000000000000000 16.760000000000000000 +54 825 50 50.0 99.64 99.64 99.640000000000000000 99.640000000000000000 +54 1165 62 62.0 69.84 69.84 69.840000000000000000 69.840000000000000000 +54 3861 NULL NULL NULL NULL NULL NULL +54 6517 40 40.0 23.38 23.38 23.380000000000000000 23.380000000000000000 +54 9159 75 75.0 55.47 55.47 55.470000000000000000 55.470000000000000000 +54 14737 38 38.0 29.2 29.2 29.200000000000000000 29.200000000000000000 +54 16059 15 15.0 7.9 7.9 7.900000000000000000 7.900000000000000000 +54 16974 NULL NULL NULL NULL NULL NULL +54 17479 34 34.0 94.14 94.14 94.140000000000000000 94.140000000000000000 +55 1339 16 16.0 71.32 71.32 71.320000000000000000 71.320000000000000000 +55 3001 7 7.0 57.58 57.58 57.580000000000000000 57.580000000000000000 +55 5137 33 33.0 57.28 57.28 57.280000000000000000 57.280000000000000000 +55 9703 44 44.0 57.21 57.21 57.210000000000000000 57.210000000000000000 +55 12170 92 92.0 69.53 69.53 69.530000000000000000 69.530000000000000000 +55 12205 90 90.0 56.92 56.92 56.920000000000000000 56.920000000000000000 +55 14135 36 36.0 26.4 26.4 26.400000000000000000 26.400000000000000000 +55 14923 71 71.0 30.04 30.04 30.040000000000000000 30.040000000000000000 +55 17677 17 17.0 26.59 26.59 26.590000000000000000 26.590000000000000000 +56 4242 2 2.0 88.74 88.74 88.740000000000000000 88.740000000000000000 +56 4506 57 57.0 69.45 69.45 69.450000000000000000 69.450000000000000000 +56 8353 35 35.0 80.42 80.42 80.420000000000000000 80.420000000000000000 +56 8691 59 59.0 98.91 98.91 98.910000000000000000 98.910000000000000000 +56 8707 68 68.0 79.7 79.7 79.700000000000000000 79.700000000000000000 +56 10362 54 54.0 82.62 82.62 82.620000000000000000 82.620000000000000000 +56 16620 23 23.0 9.94 9.94 9.940000000000000000 9.940000000000000000 +56 17331 74 74.0 32.12 32.12 32.120000000000000000 32.120000000000000000 +57 3253 71 71.0 91.02 91.02 91.020000000000000000 91.020000000000000000 +57 4028 88 88.0 82.23 82.23 82.230000000000000000 82.230000000000000000 +57 4933 22 22.0 93.86 93.86 93.860000000000000000 93.860000000000000000 +57 12596 91 91.0 36.67 36.67 36.670000000000000000 36.670000000000000000 +57 12721 62 62.0 76.4 76.4 76.400000000000000000 76.400000000000000000 +57 12740 52 52.0 55.58 55.58 55.580000000000000000 55.580000000000000000 +57 15182 86 86.0 84.85 84.85 84.850000000000000000 84.850000000000000000 +57 17729 26 26.0 97.2 97.2 97.200000000000000000 97.200000000000000000 +57 17993 99 99.0 NULL NULL NULL NULL +58 1829 52 52.0 19.97 19.97 19.970000000000000000 19.970000000000000000 +58 3848 6 6.0 45.41 45.41 45.410000000000000000 45.410000000000000000 +58 5117 2 2.0 56.01 56.01 56.010000000000000000 56.010000000000000000 +58 7649 19 19.0 44.04 44.04 44.040000000000000000 44.040000000000000000 +58 9743 62 62.0 73.14 73.14 73.140000000000000000 73.140000000000000000 +58 10802 14 14.0 79.64 79.64 79.640000000000000000 79.640000000000000000 +58 15635 6 6.0 82.45 82.45 82.450000000000000000 82.450000000000000000 +58 16472 6 6.0 7.58 7.58 7.580000000000000000 7.580000000000000000 +58 16949 35 35.0 25.76 25.76 25.760000000000000000 25.760000000000000000 +59 3133 92 92.0 14.57 14.57 14.570000000000000000 14.570000000000000000 +59 3546 22 22.0 64.21 64.21 64.210000000000000000 64.210000000000000000 +59 5772 70 70.0 56.19 56.19 56.190000000000000000 56.190000000000000000 +59 7087 80 80.0 58.71 58.71 58.710000000000000000 58.710000000000000000 +59 8010 46 46.0 20.15 20.15 20.150000000000000000 20.150000000000000000 +59 8335 36 36.0 32.82 32.82 32.820000000000000000 32.820000000000000000 +59 9348 62 62.0 83.62 83.62 83.620000000000000000 83.620000000000000000 +59 9397 92 92.0 70.69 70.69 70.690000000000000000 70.690000000000000000 +59 10651 100 100.0 35.78 35.78 35.780000000000000000 35.780000000000000000 +59 11916 19 19.0 34.31 34.31 34.310000000000000000 34.310000000000000000 +59 12858 90 90.0 61.18 61.18 61.180000000000000000 61.180000000000000000 +59 14529 44 44.0 42.76 42.76 42.760000000000000000 42.760000000000000000 +60 97 50 50.0 37.49 37.49 37.490000000000000000 37.490000000000000000 +60 555 62 62.0 49.17 49.17 49.170000000000000000 49.170000000000000000 +60 633 71 71.0 96.74 96.74 96.740000000000000000 96.740000000000000000 +60 999 43 43.0 22.13 22.13 22.130000000000000000 22.130000000000000000 +60 1117 78 78.0 46.63 46.63 46.630000000000000000 46.630000000000000000 +60 1573 90 90.0 19.02 19.02 19.020000000000000000 19.020000000000000000 +60 4041 25 25.0 36.26 36.26 36.260000000000000000 36.260000000000000000 +60 4235 28 28.0 29.67 29.67 29.670000000000000000 29.670000000000000000 +60 4513 72 72.0 79.56 79.56 79.560000000000000000 79.560000000000000000 +60 4937 22 22.0 27.75 27.75 27.750000000000000000 27.750000000000000000 +60 7231 95 95.0 45.42 45.42 45.420000000000000000 45.420000000000000000 +60 10277 62 62.0 28.05 28.05 28.050000000000000000 28.050000000000000000 +60 10393 75 75.0 98.86 98.86 98.860000000000000000 98.860000000000000000 +60 13975 14 14.0 76.01 76.01 76.010000000000000000 76.010000000000000000 +60 16887 25 25.0 17.92 17.92 17.920000000000000000 17.920000000000000000 +60 17755 88 88.0 52.17 52.17 52.170000000000000000 52.170000000000000000 +61 1106 4 4.0 78.21 78.21 78.210000000000000000 78.210000000000000000 +61 2264 36 36.0 60.94 60.94 60.940000000000000000 60.940000000000000000 +61 3362 48 48.0 67.92 67.92 67.920000000000000000 67.920000000000000000 +61 4567 26 26.0 29.6 29.6 29.600000000000000000 29.600000000000000000 +61 5528 78 78.0 13.85 13.85 13.850000000000000000 13.850000000000000000 +61 6380 77 77.0 69.52 69.52 69.520000000000000000 69.520000000000000000 +61 7591 78 78.0 91.99 91.99 91.990000000000000000 91.990000000000000000 +61 8924 11 11.0 86.51 86.51 86.510000000000000000 86.510000000000000000 +61 10330 8 8.0 46.45 46.45 46.450000000000000000 46.450000000000000000 +61 16462 26 26.0 24.34 24.34 24.340000000000000000 24.340000000000000000 +62 4093 94 94.0 5.53 5.53 5.530000000000000000 5.530000000000000000 +62 6403 NULL NULL 92.02 92.02 92.020000000000000000 92.020000000000000000 +62 8457 37 37.0 99.97 99.97 99.970000000000000000 99.970000000000000000 +62 10149 75 75.0 48.36 48.36 48.360000000000000000 48.360000000000000000 +62 12163 29 29.0 16.7 16.7 16.700000000000000000 16.700000000000000000 +62 12199 5 5.0 85.54 85.54 85.540000000000000000 85.540000000000000000 +62 12407 NULL NULL NULL NULL NULL NULL +62 13559 80 80.0 52.56 52.56 52.560000000000000000 52.560000000000000000 +62 15399 74 74.0 71.7 71.7 71.700000000000000000 71.700000000000000000 +62 15733 40 40.0 28.03 28.03 28.030000000000000000 28.030000000000000000 +62 16151 93 93.0 84.72 84.72 84.720000000000000000 84.720000000000000000 +63 4488 73 73.0 22.85 22.85 22.850000000000000000 22.850000000000000000 +63 5079 79 79.0 36.05 36.05 36.050000000000000000 36.050000000000000000 +63 5217 66 66.0 15.71 15.71 15.710000000000000000 15.710000000000000000 +63 5658 99 99.0 88.78 88.78 88.780000000000000000 88.780000000000000000 +63 9319 80 80.0 9.27 9.27 9.270000000000000000 9.270000000000000000 +63 11370 38 38.0 56.43 56.43 56.430000000000000000 56.430000000000000000 +63 11946 85 85.0 94.28 94.28 94.280000000000000000 94.280000000000000000 +63 13339 19 19.0 19.44 19.44 19.440000000000000000 19.440000000000000000 +63 15793 40 40.0 75.62 75.62 75.620000000000000000 75.620000000000000000 +63 16569 69 69.0 NULL NULL NULL NULL +64 1213 NULL NULL 38.46 38.46 38.460000000000000000 38.460000000000000000 +64 3090 87 87.0 78.06 78.06 78.060000000000000000 78.060000000000000000 +64 3963 NULL NULL NULL NULL NULL NULL +64 11835 82 82.0 30.65 30.65 30.650000000000000000 30.650000000000000000 +64 13224 NULL NULL NULL NULL NULL NULL +64 14407 8 8.0 44.36 44.36 44.360000000000000000 44.360000000000000000 +64 15867 59 59.0 43.77 43.77 43.770000000000000000 43.770000000000000000 +64 15936 30 30.0 56.24 56.24 56.240000000000000000 56.240000000000000000 +64 16921 19 19.0 98.61 98.61 98.610000000000000000 98.610000000000000000 +64 17586 78 78.0 77.26 77.26 77.260000000000000000 77.260000000000000000 +64 17617 17 17.0 91.67 91.67 91.670000000000000000 91.670000000000000000 +65 2287 100 100.0 91.8 91.8 91.800000000000000000 91.800000000000000000 +65 4227 42 42.0 45.38 45.38 45.380000000000000000 45.380000000000000000 +65 9625 51 51.0 40.95 40.95 40.950000000000000000 40.950000000000000000 +65 9847 54 54.0 64.26 64.26 64.260000000000000000 64.260000000000000000 +65 13897 40 40.0 52.84 52.84 52.840000000000000000 52.840000000000000000 +65 14905 85 85.0 81.24 81.24 81.240000000000000000 81.240000000000000000 +65 15177 55 55.0 89.19 89.19 89.190000000000000000 89.190000000000000000 +65 17025 67 67.0 25.52 25.52 25.520000000000000000 25.520000000000000000 +66 6507 76 76.0 43.81 43.81 43.810000000000000000 43.810000000000000000 +66 7033 65 65.0 4.08 4.08 4.080000000000000000 4.080000000000000000 +66 7227 66 66.0 92.15 92.15 92.150000000000000000 92.150000000000000000 +66 8197 41 41.0 84.22 84.22 84.220000000000000000 84.220000000000000000 +66 9237 29 29.0 76.94 76.94 76.940000000000000000 76.940000000000000000 +66 10019 10 10.0 48.77 48.77 48.770000000000000000 48.770000000000000000 +66 11419 66 66.0 10.12 10.12 10.120000000000000000 10.120000000000000000 +66 15629 20 20.0 22.04 22.04 22.040000000000000000 22.040000000000000000 +66 16745 91 91.0 9.53 9.53 9.530000000000000000 9.530000000000000000 +66 16795 28 28.0 42.0 42.0 42.000000000000000000 42.000000000000000000 +67 757 77 77.0 94.12 94.12 94.120000000000000000 94.120000000000000000 +67 2133 74 74.0 71.99 71.99 71.990000000000000000 71.990000000000000000 +67 3439 73 73.0 23.52 23.52 23.520000000000000000 23.520000000000000000 +67 4155 87 87.0 87.74 87.74 87.740000000000000000 87.740000000000000000 +67 5113 NULL NULL 49.59 49.59 49.590000000000000000 49.590000000000000000 +67 7020 79 79.0 97.01 97.01 97.010000000000000000 97.010000000000000000 +67 7507 77 77.0 26.78 26.78 26.780000000000000000 26.780000000000000000 +67 8469 59 59.0 NULL NULL NULL NULL +67 8871 71 71.0 78.59 78.59 78.590000000000000000 78.590000000000000000 +67 12087 70 70.0 80.71 80.71 80.710000000000000000 80.710000000000000000 +67 15699 44 44.0 34.59 34.59 34.590000000000000000 34.590000000000000000 +68 1387 74 74.0 90.2 90.2 90.200000000000000000 90.200000000000000000 +68 1603 57 57.0 21.03 21.03 21.030000000000000000 21.030000000000000000 +68 1820 54 54.0 55.82 55.82 55.820000000000000000 55.820000000000000000 +68 2035 22 22.0 54.35 54.35 54.350000000000000000 54.350000000000000000 +68 2296 52 52.0 98.9 98.9 98.900000000000000000 98.900000000000000000 +68 2564 83 83.0 77.32 77.32 77.320000000000000000 77.320000000000000000 +68 5162 23 23.0 83.48 83.48 83.480000000000000000 83.480000000000000000 +68 6763 77 77.0 96.29 96.29 96.290000000000000000 96.290000000000000000 +68 7765 NULL NULL 69.58 69.58 69.580000000000000000 69.580000000000000000 +68 12526 3 3.0 13.06 13.06 13.060000000000000000 13.060000000000000000 +68 12724 88 88.0 9.63 9.63 9.630000000000000000 9.630000000000000000 +68 17426 2 2.0 48.36 48.36 48.360000000000000000 48.360000000000000000 +68 17600 13 13.0 52.66 52.66 52.660000000000000000 52.660000000000000000 +69 322 45 45.0 NULL NULL NULL NULL +69 337 34 34.0 20.99 20.99 20.990000000000000000 20.990000000000000000 +69 4208 9 9.0 99.77 99.77 99.770000000000000000 99.770000000000000000 +69 4267 10 10.0 72.37 72.37 72.370000000000000000 72.370000000000000000 +69 6136 7 7.0 49.79 49.79 49.790000000000000000 49.790000000000000000 +69 7264 67 67.0 78.29 78.29 78.290000000000000000 78.290000000000000000 +69 7822 30 30.0 78.1 78.1 78.100000000000000000 78.100000000000000000 +69 8599 53 53.0 56.42 56.42 56.420000000000000000 56.420000000000000000 +69 11137 68 68.0 22.04 22.04 22.040000000000000000 22.040000000000000000 +69 13489 66 66.0 2.68 2.68 2.680000000000000000 2.680000000000000000 +69 13792 NULL NULL 85.64 85.64 85.640000000000000000 85.640000000000000000 +69 15448 16 16.0 94.38 94.38 94.380000000000000000 94.380000000000000000 +70 1592 53 53.0 99.59 99.59 99.590000000000000000 99.590000000000000000 +70 2462 NULL NULL 92.7 92.7 92.700000000000000000 92.700000000000000000 +70 3296 48 48.0 10.23 10.23 10.230000000000000000 10.230000000000000000 +70 3947 NULL NULL 63.8 63.8 63.800000000000000000 63.800000000000000000 +70 6185 82 82.0 84.6 84.6 84.600000000000000000 84.600000000000000000 +70 6425 NULL NULL NULL NULL NULL NULL +70 8893 17 17.0 63.51 63.51 63.510000000000000000 63.510000000000000000 +70 9857 20 20.0 54.96 54.96 54.960000000000000000 54.960000000000000000 +70 14549 4 4.0 35.39 35.39 35.390000000000000000 35.390000000000000000 +70 17815 95 95.0 36.89 36.89 36.890000000000000000 36.890000000000000000 +71 457 75 75.0 27.02 27.02 27.020000000000000000 27.020000000000000000 +71 1888 4 4.0 40.47 40.47 40.470000000000000000 40.470000000000000000 +71 2098 51 51.0 57.87 57.87 57.870000000000000000 57.870000000000000000 +71 4144 49 49.0 26.75 26.75 26.750000000000000000 26.750000000000000000 +71 5858 NULL NULL NULL NULL NULL NULL +71 6008 54 54.0 38.98 38.98 38.980000000000000000 38.980000000000000000 +71 7504 3 3.0 78.44 78.44 78.440000000000000000 78.440000000000000000 +71 8887 10 10.0 61.4 61.4 61.400000000000000000 61.400000000000000000 +71 9274 36 36.0 12.39 12.39 12.390000000000000000 12.390000000000000000 +71 9769 79 79.0 52.15 52.15 52.150000000000000000 52.150000000000000000 +71 9790 96 96.0 37.78 37.78 37.780000000000000000 37.780000000000000000 +71 9997 26 26.0 53.28 53.28 53.280000000000000000 53.280000000000000000 +71 10108 66 66.0 9.49 9.49 9.490000000000000000 9.490000000000000000 +71 10288 30 30.0 29.57 29.57 29.570000000000000000 29.570000000000000000 +71 11168 79 79.0 24.66 24.66 24.660000000000000000 24.660000000000000000 +71 17246 90 90.0 50.57 50.57 50.570000000000000000 50.570000000000000000 +72 1535 9 9.0 69.06 69.06 69.060000000000000000 69.060000000000000000 +72 5917 85 85.0 NULL NULL NULL NULL +72 6113 45 45.0 59.65 59.65 59.650000000000000000 59.650000000000000000 +72 6671 13 13.0 42.82 42.82 42.820000000000000000 42.820000000000000000 +72 9860 26 26.0 69.92 69.92 69.920000000000000000 69.920000000000000000 +72 10427 66 66.0 55.31 55.31 55.310000000000000000 55.310000000000000000 +72 10753 16 16.0 32.01 32.01 32.010000000000000000 32.010000000000000000 +72 11741 62 62.0 79.25 79.25 79.250000000000000000 79.250000000000000000 +72 12788 29 29.0 34.57 34.57 34.570000000000000000 34.570000000000000000 +72 12901 57 57.0 1.64 1.64 1.640000000000000000 1.640000000000000000 +72 13085 94 94.0 85.13 85.13 85.130000000000000000 85.130000000000000000 +72 13423 62 62.0 34.39 34.39 34.390000000000000000 34.390000000000000000 +72 13904 37 37.0 40.39 40.39 40.390000000000000000 40.390000000000000000 +72 15587 87 87.0 19.04 19.04 19.040000000000000000 19.040000000000000000 +72 16765 56 56.0 89.44 89.44 89.440000000000000000 89.440000000000000000 +73 247 53 53.0 5.22 5.22 5.220000000000000000 5.220000000000000000 +73 1063 37 37.0 34.93 34.93 34.930000000000000000 34.930000000000000000 +73 3205 82 82.0 44.64 44.64 44.640000000000000000 44.640000000000000000 +73 4946 54 54.0 71.08 71.08 71.080000000000000000 71.080000000000000000 +73 6862 58 58.0 86.48 86.48 86.480000000000000000 86.480000000000000000 +73 10051 49 49.0 97.28 97.28 97.280000000000000000 97.280000000000000000 +73 12502 75 75.0 21.63 21.63 21.630000000000000000 21.630000000000000000 +73 15109 38 38.0 53.9 53.9 53.900000000000000000 53.900000000000000000 +73 16519 97 97.0 82.11 82.11 82.110000000000000000 82.110000000000000000 +73 16585 38 38.0 69.27 69.27 69.270000000000000000 69.270000000000000000 +73 17269 40 40.0 NULL NULL NULL NULL +74 326 29 29.0 76.73 76.73 76.730000000000000000 76.730000000000000000 +74 3104 78 78.0 52.23 52.23 52.230000000000000000 52.230000000000000000 +74 3175 23 23.0 50.69 50.69 50.690000000000000000 50.690000000000000000 +74 3278 NULL NULL NULL NULL NULL NULL +74 3542 96 96.0 93.18 93.18 93.180000000000000000 93.180000000000000000 +74 3754 26 26.0 89.35 89.35 89.350000000000000000 89.350000000000000000 +74 5492 54 54.0 31.24 31.24 31.240000000000000000 31.240000000000000000 +74 7694 17 17.0 36.61 36.61 36.610000000000000000 36.610000000000000000 +74 8653 12 12.0 4.33 4.33 4.330000000000000000 4.330000000000000000 +74 9620 95 95.0 56.35 56.35 56.350000000000000000 56.350000000000000000 +74 10069 99 99.0 99.98 99.98 99.980000000000000000 99.980000000000000000 +74 13208 87 87.0 82.61 82.61 82.610000000000000000 82.610000000000000000 +74 16694 72 72.0 36.04 36.04 36.040000000000000000 36.040000000000000000 +75 607 20 20.0 88.61 88.61 88.610000000000000000 88.610000000000000000 +75 2948 25 25.0 7.48 7.48 7.480000000000000000 7.480000000000000000 +75 4625 73 73.0 76.04 76.04 76.040000000000000000 76.040000000000000000 +75 6938 89 89.0 20.73 20.73 20.730000000000000000 20.730000000000000000 +75 6953 71 71.0 33.34 33.34 33.340000000000000000 33.340000000000000000 +75 8726 6 6.0 25.87 25.87 25.870000000000000000 25.870000000000000000 +75 9905 54 54.0 63.01 63.01 63.010000000000000000 63.010000000000000000 +75 10217 85 85.0 83.25 83.25 83.250000000000000000 83.250000000000000000 +75 11039 70 70.0 87.84 87.84 87.840000000000000000 87.840000000000000000 +75 14186 63 63.0 82.77 82.77 82.770000000000000000 82.770000000000000000 +75 16796 93 93.0 5.19 5.19 5.190000000000000000 5.190000000000000000 +76 257 5 5.0 8.47 8.47 8.470000000000000000 8.470000000000000000 +76 465 2 2.0 95.45 95.45 95.450000000000000000 95.450000000000000000 +76 1107 16 16.0 NULL NULL NULL NULL +76 1503 97 97.0 30.22 30.22 30.220000000000000000 30.220000000000000000 +76 2265 98 98.0 89.7 89.7 89.700000000000000000 89.700000000000000000 +76 2869 32 32.0 NULL NULL NULL NULL +76 3363 25 25.0 89.9 89.9 89.900000000000000000 89.900000000000000000 +76 4237 48 48.0 60.58 60.58 60.580000000000000000 60.580000000000000000 +76 4567 40 40.0 2.19 2.19 2.190000000000000000 2.190000000000000000 +76 5529 78 78.0 49.64 49.64 49.640000000000000000 49.640000000000000000 +76 6381 50 50.0 34.93 34.93 34.930000000000000000 34.930000000000000000 +76 7591 27 27.0 61.86 61.86 61.860000000000000000 61.860000000000000000 +76 8925 6 6.0 80.04 80.04 80.040000000000000000 80.040000000000000000 +76 10331 3 3.0 29.09 29.09 29.090000000000000000 29.090000000000000000 +76 16463 53 53.0 86.06 86.06 86.060000000000000000 86.060000000000000000 +77 992 62 62.0 21.65 21.65 21.650000000000000000 21.650000000000000000 +77 1399 34 34.0 96.21 96.21 96.210000000000000000 96.210000000000000000 +77 2713 85 85.0 85.72 85.72 85.720000000000000000 85.720000000000000000 +77 3868 89 89.0 3.72 3.72 3.720000000000000000 3.720000000000000000 +77 6289 30 30.0 26.16 26.16 26.160000000000000000 26.160000000000000000 +77 7339 88 88.0 31.13 31.13 31.130000000000000000 31.130000000000000000 +77 7448 95 95.0 29.07 29.07 29.070000000000000000 29.070000000000000000 +77 7486 49 49.0 NULL NULL NULL NULL +77 8686 38 38.0 45.3 45.3 45.300000000000000000 45.300000000000000000 +77 9220 90 90.0 87.41 87.41 87.410000000000000000 87.410000000000000000 +77 11918 36 36.0 25.95 25.95 25.950000000000000000 25.950000000000000000 +77 12439 95 95.0 74.32 74.32 74.320000000000000000 74.320000000000000000 +77 13456 48 48.0 85.61 85.61 85.610000000000000000 85.610000000000000000 +77 14815 18 18.0 69.28 69.28 69.280000000000000000 69.280000000000000000 +77 16687 16 16.0 67.63 67.63 67.630000000000000000 67.630000000000000000 +78 901 3 3.0 54.5 54.5 54.500000000000000000 54.500000000000000000 +78 3304 50 50.0 61.49 61.49 61.490000000000000000 61.490000000000000000 +78 3856 27 27.0 60.1 60.1 60.100000000000000000 60.100000000000000000 +78 5965 78 78.0 7.47 7.47 7.470000000000000000 7.470000000000000000 +78 6044 59 59.0 15.94 15.94 15.940000000000000000 15.940000000000000000 +78 6110 43 43.0 28.45 28.45 28.450000000000000000 28.450000000000000000 +78 6500 76 76.0 38.42 38.42 38.420000000000000000 38.420000000000000000 +78 7576 87 87.0 60.62 60.62 60.620000000000000000 60.620000000000000000 +78 8611 79 79.0 95.42 95.42 95.420000000000000000 95.420000000000000000 +78 10507 6 6.0 50.83 50.83 50.830000000000000000 50.830000000000000000 +78 11209 7 7.0 88.17 88.17 88.170000000000000000 88.170000000000000000 +78 12706 19 19.0 81.1 81.1 81.100000000000000000 81.100000000000000000 +78 14996 39 39.0 36.47 36.47 36.470000000000000000 36.470000000000000000 +79 247 NULL NULL NULL NULL NULL NULL +79 1063 85 85.0 77.51 77.51 77.510000000000000000 77.510000000000000000 +79 3205 48 48.0 21.34 21.34 21.340000000000000000 21.340000000000000000 +79 4947 35 35.0 99.77 99.77 99.770000000000000000 99.770000000000000000 +79 6864 1 1.0 86.12 86.12 86.120000000000000000 86.120000000000000000 +79 10051 10 10.0 94.53 94.53 94.530000000000000000 94.530000000000000000 +79 10524 36 36.0 21.73 21.73 21.730000000000000000 21.730000000000000000 +79 12504 81 81.0 14.87 14.87 14.870000000000000000 14.870000000000000000 +79 14322 41 41.0 58.88 58.88 58.880000000000000000 58.880000000000000000 +79 15109 NULL NULL 45.07 45.07 45.070000000000000000 45.070000000000000000 +79 15498 3 3.0 94.64 94.64 94.640000000000000000 94.640000000000000000 +79 15888 58 58.0 99.75 99.75 99.750000000000000000 99.750000000000000000 +79 16519 9 9.0 69.84 69.84 69.840000000000000000 69.840000000000000000 +79 16585 93 93.0 70.7 70.7 70.700000000000000000 70.700000000000000000 +79 17269 81 81.0 5.88 5.88 5.880000000000000000 5.880000000000000000 +80 998 93 93.0 69.32 69.32 69.320000000000000000 69.320000000000000000 +80 1519 25 25.0 66.36 66.36 66.360000000000000000 66.360000000000000000 +80 1573 40 40.0 43.33 43.33 43.330000000000000000 43.330000000000000000 +80 4040 66 66.0 15.01 15.01 15.010000000000000000 15.010000000000000000 +80 4513 NULL NULL 76.02 76.02 76.020000000000000000 76.020000000000000000 +80 4622 1 1.0 60.1 60.1 60.100000000000000000 60.100000000000000000 +80 7231 49 49.0 76.07 76.07 76.070000000000000000 76.070000000000000000 +80 7610 37 37.0 24.62 24.62 24.620000000000000000 24.620000000000000000 +80 10393 5 5.0 71.37 71.37 71.370000000000000000 71.370000000000000000 +80 12968 NULL NULL NULL NULL NULL NULL +80 13717 91 91.0 60.42 60.42 60.420000000000000000 60.420000000000000000 +80 13975 13 13.0 83.81 83.81 83.810000000000000000 83.810000000000000000 +80 16363 84 84.0 84.8 84.8 84.800000000000000000 84.800000000000000000 +80 16886 77 77.0 89.22 89.22 89.220000000000000000 89.220000000000000000 +80 17308 29 29.0 94.38 94.38 94.380000000000000000 94.380000000000000000 +80 17755 94 94.0 56.04 56.04 56.040000000000000000 56.040000000000000000 +81 4486 31 31.0 63.84 63.84 63.840000000000000000 63.840000000000000000 +81 5078 75 75.0 33.72 33.72 33.720000000000000000 33.720000000000000000 +81 5216 64 64.0 4.59 4.59 4.590000000000000000 4.590000000000000000 +81 5656 24 24.0 40.61 40.61 40.610000000000000000 40.610000000000000000 +81 7166 7 7.0 22.87 22.87 22.870000000000000000 22.870000000000000000 +81 7663 79 79.0 52.07 52.07 52.070000000000000000 52.070000000000000000 +81 8918 37 37.0 86.54 86.54 86.540000000000000000 86.540000000000000000 +81 9319 36 36.0 91.74 91.74 91.740000000000000000 91.740000000000000000 +81 11107 36 36.0 47.86 47.86 47.860000000000000000 47.860000000000000000 +81 11368 26 26.0 NULL NULL NULL NULL +81 13339 6 6.0 4.63 4.63 4.630000000000000000 4.630000000000000000 +81 15793 8 8.0 5.61 5.61 5.610000000000000000 5.610000000000000000 +82 2572 53 53.0 55.41 55.41 55.410000000000000000 55.410000000000000000 +82 7862 75 75.0 21.65 21.65 21.650000000000000000 21.650000000000000000 +82 13138 59 59.0 31.81 31.81 31.810000000000000000 31.810000000000000000 +82 14998 49 49.0 52.59 52.59 52.590000000000000000 52.590000000000000000 +82 17041 18 18.0 4.71 4.71 4.710000000000000000 4.710000000000000000 diff --git ql/src/test/results/clientpositive/llap/vector_grouping_sets.q.out ql/src/test/results/clientpositive/llap/vector_grouping_sets.q.out index 9d51982..8eb901a 100644 --- ql/src/test/results/clientpositive/llap/vector_grouping_sets.q.out +++ ql/src/test/results/clientpositive/llap/vector_grouping_sets.q.out @@ -168,9 +168,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1, ConstantVectorExpression(val 0) -> 29:long native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: s_store_id (type: string), 0 (type: int) mode: hash @@ -208,9 +210,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: string), KEY._col1 (type: int) mode: mergepartial @@ -298,9 +302,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1, ConstantVectorExpression(val 0) -> 29:long native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: string), 0 (type: int) mode: hash @@ -338,9 +344,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: string), KEY._col1 (type: int) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_include_no_sel.q.out ql/src/test/results/clientpositive/llap/vector_include_no_sel.q.out index 029b3f5..07c9157 100644 --- ql/src/test/results/clientpositive/llap/vector_include_no_sel.q.out +++ ql/src/test/results/clientpositive/llap/vector_include_no_sel.q.out @@ -257,8 +257,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 25:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -297,8 +299,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_inner_join.q.out ql/src/test/results/clientpositive/llap/vector_inner_join.q.out index fc7b9a3..7ba4a45 100644 --- ql/src/test/results/clientpositive/llap/vector_inner_join.q.out +++ ql/src/test/results/clientpositive/llap/vector_inner_join.q.out @@ -302,9 +302,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash diff --git ql/src/test/results/clientpositive/llap/vector_join30.q.out ql/src/test/results/clientpositive/llap/vector_join30.q.out index 6af0959..e5dcccf 100644 --- ql/src/test/results/clientpositive/llap/vector_join30.q.out +++ ql/src/test/results/clientpositive/llap/vector_join30.q.out @@ -164,8 +164,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(VectorUDFAdaptor(hash(_col2,_col3)) -> 2:int) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -193,8 +195,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -403,8 +407,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(VectorUDFAdaptor(hash(_col2,_col3)) -> 3:int) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -432,8 +438,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -669,8 +677,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(VectorUDFAdaptor(hash(_col2,_col3)) -> 2:int) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -698,8 +708,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -947,8 +959,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(VectorUDFAdaptor(hash(_col2,_col3)) -> 2:int) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -976,8 +990,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1268,8 +1284,10 @@ STAGE PLANS: Group By Operator aggregations: sum(hash(_col2,_col3)) Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1293,8 +1311,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1585,8 +1605,10 @@ STAGE PLANS: Group By Operator aggregations: sum(hash(_col2,_col3)) Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1610,8 +1632,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1902,8 +1926,10 @@ STAGE PLANS: Group By Operator aggregations: sum(hash(_col2,_col3)) Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1927,8 +1953,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -2219,8 +2247,10 @@ STAGE PLANS: Group By Operator aggregations: sum(hash(_col2,_col3)) Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -2244,8 +2274,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_join_part_col_char.q.out ql/src/test/results/clientpositive/llap/vector_join_part_col_char.q.out index 95dcba9..8d40a6d 100644 --- ql/src/test/results/clientpositive/llap/vector_join_part_col_char.q.out +++ ql/src/test/results/clientpositive/llap/vector_join_part_col_char.q.out @@ -111,24 +111,24 @@ Stage-0 Reducer 2 llap File Output Operator [FS_10] Merge Join Operator [MERGEJOIN_21] (rows=2 width=431) - Conds:RS_23._col2=RS_28._col2(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] + Conds:RS_6._col2=RS_7._col2(Inner),Output:["_col0","_col1","_col2","_col3","_col4","_col5"] <-Map 1 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_23] + SHUFFLE [RS_6] PartitionCols:_col2 - Select Operator [SEL_22] (rows=2 width=134) + Select Operator [SEL_2] (rows=2 width=134) Output:["_col0","_col1","_col2"] TableScan [TS_0] (rows=2 width=236) default@char_tbl1,c1,Tbl:COMPLETE,Col:PARTIAL,Output:["name","age"] - Dynamic Partitioning Event Operator [EVENT_26] (rows=1 width=134) - Group By Operator [GBY_25] (rows=1 width=134) + Dynamic Partitioning Event Operator [EVENT_20] (rows=1 width=134) + Group By Operator [GBY_19] (rows=1 width=134) Output:["_col0"],keys:_col0 - Select Operator [SEL_24] (rows=2 width=134) + Select Operator [SEL_18] (rows=2 width=134) Output:["_col0"] - Please refer to the previous Select Operator [SEL_22] + Please refer to the previous Select Operator [SEL_2] <-Map 3 [SIMPLE_EDGE] vectorized, llap - SHUFFLE [RS_28] + SHUFFLE [RS_7] PartitionCols:_col2 - Select Operator [SEL_27] (rows=2 width=89) + Select Operator [SEL_5] (rows=2 width=89) Output:["_col0","_col1","_col2"] TableScan [TS_3] (rows=2 width=190) default@char_tbl2,c2,Tbl:COMPLETE,Col:PARTIAL,Output:["name","age"] diff --git ql/src/test/results/clientpositive/llap/vector_leftsemi_mapjoin.q.out ql/src/test/results/clientpositive/llap/vector_leftsemi_mapjoin.q.out index 6c6d0f3..47be1af 100644 --- ql/src/test/results/clientpositive/llap/vector_leftsemi_mapjoin.q.out +++ ql/src/test/results/clientpositive/llap/vector_leftsemi_mapjoin.q.out @@ -3389,8 +3389,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -3500,8 +3502,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -3613,8 +3617,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -3721,8 +3727,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -3837,8 +3845,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -3919,8 +3929,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4030,8 +4042,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4138,8 +4152,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4274,8 +4290,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4398,8 +4416,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4531,8 +4551,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4652,8 +4674,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkMultiKeyOperator native: true @@ -4771,8 +4795,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4799,8 +4825,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -4932,8 +4960,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -5072,8 +5102,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -5198,8 +5230,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -5342,8 +5376,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -5488,8 +5524,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -5661,8 +5699,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkLongOperator native: true @@ -5822,8 +5862,10 @@ STAGE PLANS: native: true Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH Reduce Sink Vectorization: className: VectorReduceSinkStringOperator native: true @@ -5954,9 +5996,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -6145,9 +6189,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -6338,9 +6384,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -6531,9 +6579,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col1 (type: int), _col1 (type: int) mode: hash @@ -6727,9 +6777,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -6862,9 +6914,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -7058,9 +7112,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -7251,9 +7307,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -7494,9 +7552,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -7698,9 +7758,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -7942,9 +8004,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -8143,9 +8207,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -8345,9 +8411,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -8403,9 +8471,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -8625,9 +8695,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -8842,9 +8914,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -9047,9 +9121,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -9284,9 +9360,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -9523,9 +9601,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -9816,9 +9896,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -10079,9 +10161,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: string) mode: hash @@ -10233,9 +10317,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -10427,9 +10513,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -10623,9 +10711,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -10819,9 +10909,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col1 (type: int), _col1 (type: int) mode: hash @@ -11018,9 +11110,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -11153,9 +11247,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -11352,9 +11448,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -11548,9 +11646,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -11797,9 +11897,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -12004,9 +12106,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -12248,9 +12352,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -12452,9 +12558,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -12654,9 +12762,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -12712,9 +12822,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -12934,9 +13046,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -13151,9 +13265,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -13356,9 +13472,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -13593,9 +13711,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -13832,9 +13952,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -14131,9 +14253,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -14397,9 +14521,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: string) mode: hash @@ -14551,9 +14677,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -14745,9 +14873,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -14941,9 +15071,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -15137,9 +15269,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col1 (type: int), _col1 (type: int) mode: hash @@ -15336,9 +15470,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -15471,9 +15607,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -15670,9 +15808,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -15866,9 +16006,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -16115,9 +16257,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -16322,9 +16466,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -16566,9 +16712,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -16770,9 +16918,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: string) mode: hash @@ -16972,9 +17122,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -17030,9 +17182,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -17252,9 +17406,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -17469,9 +17625,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -17674,9 +17832,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -17911,9 +18071,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -18150,9 +18312,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -18449,9 +18613,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -18715,9 +18881,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: string) mode: hash diff --git ql/src/test/results/clientpositive/llap/vector_mapjoin_reduce.q.out ql/src/test/results/clientpositive/llap/vector_mapjoin_reduce.q.out index ef67ec2..000cbd5 100644 --- ql/src/test/results/clientpositive/llap/vector_mapjoin_reduce.q.out +++ ql/src/test/results/clientpositive/llap/vector_mapjoin_reduce.q.out @@ -44,9 +44,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: l_partkey (type: int) mode: hash @@ -140,9 +142,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int) mode: hash @@ -180,9 +184,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial @@ -311,9 +317,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: l_partkey (type: int) mode: hash @@ -408,9 +416,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 3 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: int), _col1 (type: int) mode: hash @@ -448,9 +458,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: int) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_non_constant_in_expr.q.out ql/src/test/results/clientpositive/llap/vector_non_constant_in_expr.q.out index 6edc474..10051d1 100644 --- ql/src/test/results/clientpositive/llap/vector_non_constant_in_expr.q.out +++ ql/src/test/results/clientpositive/llap/vector_non_constant_in_expr.q.out @@ -21,7 +21,7 @@ STAGE PLANS: alias: alltypesorc Statistics: Num rows: 12288 Data size: 3093170 Basic stats: COMPLETE Column stats: COMPLETE Filter Operator - predicate: (cint) IN (ctinyint, cbigint) (type: boolean) + predicate: (cint) IN (UDFToInteger(ctinyint), UDFToInteger(cbigint)) (type: boolean) Statistics: Num rows: 6144 Data size: 1546640 Basic stats: COMPLETE Column stats: COMPLETE Select Operator expressions: ctinyint (type: tinyint), csmallint (type: smallint), cint (type: int), cbigint (type: bigint), cfloat (type: float), cdouble (type: double), cstring1 (type: string), cstring2 (type: string), ctimestamp1 (type: timestamp), ctimestamp2 (type: timestamp), cboolean1 (type: boolean), cboolean2 (type: boolean) @@ -40,7 +40,7 @@ STAGE PLANS: enabled: true enabledConditionsMet: hive.vectorized.use.vectorized.input.format IS true inputFileFormats: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat - notVectorizedReason: Predicate expression for FILTER operator: Cannot vectorize IN() - casting a column is not supported. Column type is int but the common type is bigint + notVectorizedReason: Predicate expression for FILTER operator: Vectorizing IN expression only supported for constant values vectorized: false Stage: Stage-0 diff --git ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out index 5c20455..59746d9 100644 --- ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out +++ ql/src/test/results/clientpositive/llap/vector_number_compare_projection.q.out @@ -181,8 +181,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 6) -> bigint className: VectorGroupByOperator + groupByMode: COMPLETE vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: complete outputColumnNames: _col0 @@ -305,8 +307,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 8) -> bigint className: VectorGroupByOperator + groupByMode: COMPLETE vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: complete outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_orderby_5.q.out ql/src/test/results/clientpositive/llap/vector_orderby_5.q.out index 2a8eda6..4e4e410 100644 --- ql/src/test/results/clientpositive/llap/vector_orderby_5.q.out +++ ql/src/test/results/clientpositive/llap/vector_orderby_5.q.out @@ -145,9 +145,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 7 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: bo (type: boolean) mode: hash @@ -188,9 +190,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: boolean) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_outer_join1.q.out ql/src/test/results/clientpositive/llap/vector_outer_join1.q.out index c089d00..6730ae3 100644 --- ql/src/test/results/clientpositive/llap/vector_outer_join1.q.out +++ ql/src/test/results/clientpositive/llap/vector_outer_join1.q.out @@ -732,8 +732,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint, VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] mode: hash outputColumnNames: _col0, _col1 @@ -862,8 +864,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint, VectorUDAFSumLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1] mode: mergepartial outputColumnNames: _col0, _col1 diff --git ql/src/test/results/clientpositive/llap/vector_outer_join2.q.out ql/src/test/results/clientpositive/llap/vector_outer_join2.q.out index f1319a9..452ebc9 100644 --- ql/src/test/results/clientpositive/llap/vector_outer_join2.q.out +++ ql/src/test/results/clientpositive/llap/vector_outer_join2.q.out @@ -318,8 +318,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint, VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] mode: hash outputColumnNames: _col0, _col1 @@ -448,8 +450,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint, VectorUDAFSumLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1] mode: mergepartial outputColumnNames: _col0, _col1 diff --git ql/src/test/results/clientpositive/llap/vector_partition_diff_num_cols.q.out ql/src/test/results/clientpositive/llap/vector_partition_diff_num_cols.q.out index 3e4ae94..f163cd7 100644 --- ql/src/test/results/clientpositive/llap/vector_partition_diff_num_cols.q.out +++ ql/src/test/results/clientpositive/llap/vector_partition_diff_num_cols.q.out @@ -115,8 +115,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -154,8 +156,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -284,8 +288,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -323,8 +329,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -453,8 +461,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -492,8 +502,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -609,8 +621,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -648,8 +662,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -765,8 +781,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -804,8 +822,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out index 2870d9e..8518daa 100644 --- ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out +++ ql/src/test/results/clientpositive/llap/vector_partitioned_date_time.q.out @@ -456,9 +456,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 2 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: fl_date (type: date) mode: hash @@ -499,9 +501,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: date) mode: mergepartial @@ -1390,9 +1394,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 5 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: fl_date (type: date) mode: hash @@ -1433,9 +1439,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: date) mode: mergepartial @@ -2348,9 +2356,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 5 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: fl_time (type: timestamp) mode: hash @@ -2391,9 +2401,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: timestamp) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_reduce_groupby_decimal.q.out ql/src/test/results/clientpositive/llap/vector_reduce_groupby_decimal.q.out index 964e63d..6923118 100644 --- ql/src/test/results/clientpositive/llap/vector_reduce_groupby_decimal.q.out +++ ql/src/test/results/clientpositive/llap/vector_reduce_groupby_decimal.q.out @@ -65,9 +65,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinDecimal(col 2) -> decimal(20,10) className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 1, col 2, col 3 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: cint (type: int), cdouble (type: double), cdecimal1 (type: decimal(20,10)), cdecimal2 (type: decimal(23,14)) mode: hash @@ -110,9 +112,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinDecimal(col 4) -> decimal(20,10) className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1, col 2, col 3 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: int), KEY._col1 (type: double), KEY._col2 (type: decimal(20,10)), KEY._col3 (type: decimal(23,14)) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_string_concat.q.out ql/src/test/results/clientpositive/llap/vector_string_concat.q.out index 8b19c58..392a2a9 100644 --- ql/src/test/results/clientpositive/llap/vector_string_concat.q.out +++ ql/src/test/results/clientpositive/llap/vector_string_concat.q.out @@ -356,9 +356,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 19 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: _col0 (type: string) mode: hash @@ -398,9 +400,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vector_string_decimal.q.out ql/src/test/results/clientpositive/llap/vector_string_decimal.q.out index c036d69..6b4ca6c 100644 --- ql/src/test/results/clientpositive/llap/vector_string_decimal.q.out +++ ql/src/test/results/clientpositive/llap/vector_string_decimal.q.out @@ -62,28 +62,44 @@ STAGE PLANS: TableScan alias: orc_decimal Statistics: Num rows: 4 Data size: 448 Basic stats: COMPLETE Column stats: NONE + TableScan Vectorization: + native: true + projectedOutputColumns: [0] Filter Operator - predicate: (id) IN ('100000000', '200000000') (type: boolean) + Filter Vectorization: + className: VectorFilterOperator + native: true + predicateExpression: FilterDoubleColumnInList(col 1, values [1.0E8, 2.0E8])(children: CastDecimalToDouble(col 0) -> 1:double) -> boolean + predicate: (UDFToDouble(id)) IN (1.0E8, 2.0E8) (type: boolean) Statistics: Num rows: 2 Data size: 224 Basic stats: COMPLETE Column stats: NONE Select Operator expressions: id (type: decimal(18,0)) outputColumnNames: _col0 + Select Vectorization: + className: VectorSelectOperator + native: true + projectedOutputColumns: [0] Statistics: Num rows: 2 Data size: 224 Basic stats: COMPLETE Column stats: NONE File Output Operator compressed: false + File Sink Vectorization: + className: VectorFileSinkOperator + native: false Statistics: Num rows: 2 Data size: 224 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 - Execution mode: llap + Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: enabled: true enabledConditionsMet: hive.vectorized.use.vectorized.input.format IS true + groupByVectorOutput: true inputFileFormats: org.apache.hadoop.hive.ql.io.orc.OrcInputFormat - notVectorizedReason: Predicate expression for FILTER operator: Cannot vectorize IN() - casting a column is not supported. Column type is decimal(18,0) but the common type is string - vectorized: false + allNative: false + usesVectorUDFAdaptor: false + vectorized: true Stage: Stage-0 Fetch Operator diff --git ql/src/test/results/clientpositive/llap/vector_tablesample_rows.q.out ql/src/test/results/clientpositive/llap/vector_tablesample_rows.q.out index 31b834a..6659318 100644 --- ql/src/test/results/clientpositive/llap/vector_tablesample_rows.q.out +++ ql/src/test/results/clientpositive/llap/vector_tablesample_rows.q.out @@ -253,8 +253,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 1:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -282,8 +284,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vector_when_case_null.q.out ql/src/test/results/clientpositive/llap/vector_when_case_null.q.out index 8104f3e..0245f84 100644 --- ql/src/test/results/clientpositive/llap/vector_when_case_null.q.out +++ ql/src/test/results/clientpositive/llap/vector_when_case_null.q.out @@ -58,9 +58,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: _col0 (type: string) mode: hash @@ -101,9 +103,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: string) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vectorization_0.q.out ql/src/test/results/clientpositive/llap/vectorization_0.q.out index d2897ba..866e780 100644 --- ql/src/test/results/clientpositive/llap/vectorization_0.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_0.q.out @@ -52,8 +52,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> tinyint, VectorUDAFMaxLong(col 0) -> tinyint, VectorUDAFCount(col 0) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] mode: hash outputColumnNames: _col0, _col1, _col2, _col3 @@ -91,8 +93,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> tinyint, VectorUDAFMaxLong(col 1) -> tinyint, VectorUDAFCountMerge(col 2) -> bigint, VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1, 2, 3] mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 @@ -208,8 +212,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -247,8 +253,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -509,8 +517,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 3) -> bigint, VectorUDAFMaxLong(col 3) -> bigint, VectorUDAFCount(col 3) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] mode: hash outputColumnNames: _col0, _col1, _col2, _col3 @@ -548,8 +558,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> bigint, VectorUDAFMaxLong(col 1) -> bigint, VectorUDAFCountMerge(col 2) -> bigint, VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1, 2, 3] mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 @@ -665,8 +677,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 3) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -704,8 +718,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -966,8 +982,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinDouble(col 4) -> float, VectorUDAFMaxDouble(col 4) -> float, VectorUDAFCount(col 4) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] mode: hash outputColumnNames: _col0, _col1, _col2, _col3 @@ -1005,8 +1023,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinDouble(col 0) -> float, VectorUDAFMaxDouble(col 1) -> float, VectorUDAFCountMerge(col 2) -> bigint, VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1, 2, 3] mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 @@ -1122,8 +1142,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumDouble(col 4) -> double className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -1161,8 +1183,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumDouble(col 0) -> double className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1468,8 +1492,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgLong(col 3) -> struct, VectorUDAFStdPopLong(col 3) -> struct, VectorUDAFVarSampLong(col 3) -> struct, VectorUDAFCountStar(*) -> bigint, VectorUDAFSumDouble(col 4) -> double, VectorUDAFMinLong(col 0) -> tinyint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarSampLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash diff --git ql/src/test/results/clientpositive/llap/vectorization_13.q.out ql/src/test/results/clientpositive/llap/vectorization_13.q.out index 3ae67b6..2e37e0f 100644 --- ql/src/test/results/clientpositive/llap/vectorization_13.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_13.q.out @@ -109,9 +109,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 0) -> tinyint, VectorUDAFSumDouble(col 4) -> double, VectorUDAFStdPopDouble(col 4) -> struct, VectorUDAFStdPopLong(col 0) -> struct, VectorUDAFMaxDouble(col 4) -> float, VectorUDAFMinLong(col 0) -> tinyint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 10, col 0, col 8, col 4, col 6 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5] vectorOutputConditionsNotMet: Vector output of VectorUDAFStdPopDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false keys: cboolean1 (type: boolean), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cfloat (type: float), cstring1 (type: string) @@ -417,9 +419,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 0) -> tinyint, VectorUDAFSumDouble(col 4) -> double, VectorUDAFStdPopDouble(col 4) -> struct, VectorUDAFStdPopLong(col 0) -> struct, VectorUDAFMaxDouble(col 4) -> float, VectorUDAFMinLong(col 0) -> tinyint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 10, col 0, col 8, col 4, col 6 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5] vectorOutputConditionsNotMet: Vector output of VectorUDAFStdPopDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false keys: cboolean1 (type: boolean), ctinyint (type: tinyint), ctimestamp1 (type: timestamp), cfloat (type: float), cstring1 (type: string) diff --git ql/src/test/results/clientpositive/llap/vectorization_limit.q.out ql/src/test/results/clientpositive/llap/vectorization_limit.q.out index c38a215..163e6a6 100644 --- ql/src/test/results/clientpositive/llap/vectorization_limit.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_limit.q.out @@ -250,9 +250,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgDouble(col 12) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgDouble(col 12) -> struct output type STRUCT requires PRIMITIVE IS false keys: _col0 (type: tinyint) @@ -376,9 +378,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: ctinyint (type: tinyint) mode: hash @@ -418,9 +422,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: tinyint) mode: mergepartial @@ -457,26 +463,26 @@ POSTHOOK: query: select distinct(ctinyint) from alltypesorc limit 20 POSTHOOK: type: QUERY POSTHOOK: Input: default@alltypesorc #### A masked pattern was here #### +-59 +-58 +-54 +-50 NULL +-60 +-56 +-49 +-46 -64 -63 -62 -61 --60 --59 --58 --57 --56 -55 --54 -53 -52 -51 --50 --49 +-57 -48 -47 --46 PREHOOK: query: explain vectorization expression select ctinyint, count(distinct(cdouble)) from alltypesorc group by ctinyint order by ctinyint limit 20 PREHOOK: type: QUERY @@ -518,9 +524,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 0, col 5 native: false + vectorProcessingMode: HASH projectedOutputColumns: [] keys: ctinyint (type: tinyint), cdouble (type: double) mode: hash @@ -558,9 +566,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: tinyint), KEY._col1 (type: double) mode: mergepartial @@ -571,9 +581,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 1) -> bigint className: VectorGroupByOperator + groupByMode: COMPLETE vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0] keys: _col0 (type: tinyint) mode: complete @@ -696,37 +708,31 @@ STAGE PLANS: predicateExpression: SelectColumnIsNotNull(col 0) -> boolean predicate: ctinyint is not null (type: boolean) Statistics: Num rows: 9173 Data size: 82188 Basic stats: COMPLETE Column stats: COMPLETE - Select Operator - expressions: cdouble (type: double), ctinyint (type: tinyint) - outputColumnNames: cdouble, ctinyint - Select Vectorization: - className: VectorSelectOperator - native: true - projectedOutputColumns: [5, 0] - Statistics: Num rows: 9173 Data size: 82188 Basic stats: COMPLETE Column stats: COMPLETE - Group By Operator - aggregations: sum(ctinyint) - Group By Vectorization: - aggregators: VectorUDAFSumLong(col 0) -> bigint - className: VectorGroupByOperator - vectorOutput: true - keyExpressions: col 5 - native: false - projectedOutputColumns: [0] - keys: cdouble (type: double) - mode: hash - outputColumnNames: _col0, _col1 + Group By Operator + aggregations: sum(ctinyint) + Group By Vectorization: + aggregators: VectorUDAFSumLong(col 0) -> bigint + className: VectorGroupByOperator + groupByMode: HASH + vectorOutput: true + keyExpressions: col 5 + native: false + vectorProcessingMode: HASH + projectedOutputColumns: [0] + keys: cdouble (type: double) + mode: hash + outputColumnNames: _col0, _col1 + Statistics: Num rows: 3185 Data size: 44512 Basic stats: COMPLETE Column stats: COMPLETE + Reduce Output Operator + key expressions: _col0 (type: double) + sort order: + + Map-reduce partition columns: _col0 (type: double) + Reduce Sink Vectorization: + className: VectorReduceSinkMultiKeyOperator + native: true + nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true Statistics: Num rows: 3185 Data size: 44512 Basic stats: COMPLETE Column stats: COMPLETE - Reduce Output Operator - key expressions: _col0 (type: double) - sort order: + - Map-reduce partition columns: _col0 (type: double) - Reduce Sink Vectorization: - className: VectorReduceSinkMultiKeyOperator - native: true - nativeConditionsMet: hive.vectorized.execution.reducesink.new.enabled IS true, hive.execution.engine tez IN [tez, spark] IS true, No TopN IS true, No DISTINCT columns IS true, BinarySortableSerDe for keys IS true, LazyBinarySerDe for values IS true - Statistics: Num rows: 3185 Data size: 44512 Basic stats: COMPLETE Column stats: COMPLETE - value expressions: _col1 (type: bigint) + value expressions: _col1 (type: bigint) Execution mode: vectorized, llap LLAP IO: all inputs Map Vectorization: @@ -752,9 +758,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [0] keys: KEY._col0 (type: double) mode: mergepartial diff --git ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out index f0b28fa..21692d3 100644 --- ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out +++ ql/src/test/results/clientpositive/llap/vectorization_short_regress.q.out @@ -116,8 +116,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgLong(col 2) -> struct, VectorUDAFSumDouble(col 5) -> double, VectorUDAFStdPopLong(col 2) -> struct, VectorUDAFStdSampLong(col 1) -> struct, VectorUDAFVarSampLong(col 2) -> struct, VectorUDAFAvgDouble(col 4) -> struct, VectorUDAFStdSampLong(col 2) -> struct, VectorUDAFMinLong(col 0) -> tinyint, VectorUDAFCount(col 1) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarSampLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash @@ -357,8 +359,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 2) -> int, VectorUDAFVarPopLong(col 3) -> struct, VectorUDAFStdPopLong(col 1) -> struct, VectorUDAFMaxDouble(col 5) -> double, VectorUDAFAvgLong(col 0) -> struct, VectorUDAFMinLong(col 2) -> int, VectorUDAFMinDouble(col 5) -> double, VectorUDAFStdSampLong(col 1) -> struct, VectorUDAFVarSampLong(col 2) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8] vectorOutputConditionsNotMet: Vector output of VectorUDAFVarPopLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarSampLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash @@ -590,8 +594,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFVarPopLong(col 3) -> struct, VectorUDAFCountStar(*) -> bigint, VectorUDAFMaxLong(col 0) -> tinyint, VectorUDAFStdPopLong(col 1) -> struct, VectorUDAFMaxLong(col 2) -> int, VectorUDAFStdSampDouble(col 5) -> struct, VectorUDAFCount(col 0) -> bigint, VectorUDAFAvgLong(col 0) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7] vectorOutputConditionsNotMet: Vector output of VectorUDAFVarPopLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampDouble(col 5) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash @@ -802,8 +808,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgLong(col 0) -> struct, VectorUDAFMaxLong(col 3) -> bigint, VectorUDAFStdSampLong(col 2) -> struct, VectorUDAFVarPopLong(col 2) -> struct, VectorUDAFVarPopLong(col 3) -> struct, VectorUDAFMaxDouble(col 4) -> float className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash @@ -2123,9 +2131,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFStdSampLong(col 1) -> struct, VectorUDAFSumLong(col 3) -> bigint, VectorUDAFVarPopLong(col 0) -> struct, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] vectorOutputConditionsNotMet: Vector output of VectorUDAFStdSampLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false keys: csmallint (type: smallint) @@ -2378,9 +2388,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFVarSampDouble(col 5) -> struct, VectorUDAFCount(col 4) -> bigint, VectorUDAFSumDouble(col 4) -> double, VectorUDAFVarPopDouble(col 5) -> struct, VectorUDAFStdPopDouble(col 5) -> struct, VectorUDAFSumDouble(col 5) -> double className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 5 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5] vectorOutputConditionsNotMet: Vector output of VectorUDAFVarSampDouble(col 5) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopDouble(col 5) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopDouble(col 5) -> struct output type STRUCT requires PRIMITIVE IS false keys: cdouble (type: double) @@ -2677,9 +2689,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFStdPopLong(col 2) -> struct, VectorUDAFAvgLong(col 1) -> struct, VectorUDAFCountStar(*) -> bigint, VectorUDAFMinLong(col 0) -> tinyint, VectorUDAFVarSampLong(col 1) -> struct, VectorUDAFVarPopDouble(col 4) -> struct, VectorUDAFAvgLong(col 2) -> struct, VectorUDAFVarSampDouble(col 4) -> struct, VectorUDAFAvgDouble(col 4) -> struct, VectorUDAFMinDouble(col 5) -> double, VectorUDAFVarPopLong(col 1) -> struct, VectorUDAFStdPopLong(col 0) -> struct, VectorUDAFSumLong(col 2) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 8, col 6 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12] vectorOutputConditionsNotMet: Vector output of VectorUDAFStdPopLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarSampLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarSampDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false keys: ctimestamp1 (type: timestamp), cstring1 (type: string) @@ -3057,9 +3071,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxDouble(col 4) -> float, VectorUDAFSumLong(col 3) -> bigint, VectorUDAFVarSampLong(col 2) -> struct, VectorUDAFAvgDouble(col 5) -> struct, VectorUDAFMinLong(col 3) -> bigint, VectorUDAFVarPopLong(col 3) -> struct, VectorUDAFSumLong(col 2) -> bigint, VectorUDAFStdSampLong(col 0) -> struct, VectorUDAFStdPopLong(col 1) -> struct, VectorUDAFAvgLong(col 2) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 10 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] vectorOutputConditionsNotMet: Vector output of VectorUDAFVarSampLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgDouble(col 5) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopLong(col 3) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampLong(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopLong(col 1) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFAvgLong(col 2) -> struct output type STRUCT requires PRIMITIVE IS false keys: cboolean1 (type: boolean) @@ -3275,8 +3291,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -3314,8 +3332,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -3389,8 +3409,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -3428,8 +3450,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -3575,8 +3599,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -3614,8 +3640,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -3689,8 +3717,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 0) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -3728,8 +3758,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -3803,8 +3835,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 2) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -3842,8 +3876,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -3917,8 +3953,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 4) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -3956,8 +3994,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -4031,8 +4071,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 6) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -4070,8 +4112,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -4145,8 +4189,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 10) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -4184,8 +4230,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vectorized_case.q.out ql/src/test/results/clientpositive/llap/vectorized_case.q.out index 940b36e..a6a1e70 100644 --- ql/src/test/results/clientpositive/llap/vectorized_case.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_case.q.out @@ -290,8 +290,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 12) -> bigint, VectorUDAFSumLong(col 13) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] mode: hash outputColumnNames: _col0, _col1 @@ -329,8 +331,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint, VectorUDAFSumLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1] mode: mergepartial outputColumnNames: _col0, _col1 @@ -417,8 +421,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 12) -> bigint, VectorUDAFSumLong(col 13) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1] mode: hash outputColumnNames: _col0, _col1 @@ -456,8 +462,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumLong(col 0) -> bigint, VectorUDAFSumLong(col 1) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1] mode: mergepartial outputColumnNames: _col0, _col1 diff --git ql/src/test/results/clientpositive/llap/vectorized_date_funcs.q.out ql/src/test/results/clientpositive/llap/vectorized_date_funcs.q.out index c98ea9c..1bef1cf 100644 --- ql/src/test/results/clientpositive/llap/vectorized_date_funcs.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_date_funcs.q.out @@ -1261,8 +1261,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> date, VectorUDAFMaxLong(col 0) -> date, VectorUDAFCount(col 0) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] mode: hash outputColumnNames: _col0, _col1, _col2, _col3 @@ -1300,8 +1302,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> date, VectorUDAFMaxLong(col 1) -> date, VectorUDAFCountMerge(col 2) -> bigint, VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1, 2, 3] mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 diff --git ql/src/test/results/clientpositive/llap/vectorized_dynamic_semijoin_reduction.q.out ql/src/test/results/clientpositive/llap/vectorized_dynamic_semijoin_reduction.q.out index 5a7a101..c64bd6e 100644 --- ql/src/test/results/clientpositive/llap/vectorized_dynamic_semijoin_reduction.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_dynamic_semijoin_reduction.q.out @@ -136,8 +136,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 1) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilter(col 1) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -173,8 +175,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -198,8 +202,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -229,8 +235,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -373,8 +381,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinString(col 0) -> string, VectorUDAFMaxString(col 0) -> string, VectorUDAFBloomFilter(col 0) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -410,8 +420,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -435,8 +447,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -466,8 +480,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinString(col 0) -> string, VectorUDAFMaxString(col 1) -> string, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -610,8 +626,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinString(col 0) -> string, VectorUDAFMaxString(col 0) -> string, VectorUDAFBloomFilter(col 0) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -647,8 +665,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -672,8 +692,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -703,8 +725,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinString(col 0) -> string, VectorUDAFMaxString(col 1) -> string, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -848,8 +872,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 1) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilter(col 1) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -918,8 +944,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 1) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilter(col 1) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -957,8 +985,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -982,8 +1012,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1013,8 +1045,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -1042,8 +1076,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -1187,8 +1223,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinString(col 0) -> string, VectorUDAFMaxString(col 0) -> string, VectorUDAFBloomFilter(col 0) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -1214,8 +1252,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 1) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilter(col 1) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -1251,8 +1291,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1276,8 +1318,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1307,8 +1351,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinString(col 0) -> string, VectorUDAFMaxString(col 1) -> string, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -1336,8 +1382,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 @@ -1480,8 +1528,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 1) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilter(col 1) -> binary className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2] mode: hash outputColumnNames: _col0, _col1, _col2 @@ -1517,8 +1567,10 @@ STAGE PLANS: Group By Operator aggregations: count() Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0 @@ -1542,8 +1594,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1573,8 +1627,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinLong(col 0) -> int, VectorUDAFMaxLong(col 1) -> int, VectorUDAFBloomFilterMerge(col 2) -> binary className: VectorGroupByOperator + groupByMode: FINAL vectorOutput: true native: false + vectorProcessingMode: STREAMING projectedOutputColumns: [0, 1, 2] mode: final outputColumnNames: _col0, _col1, _col2 diff --git ql/src/test/results/clientpositive/llap/vectorized_mapjoin.q.out ql/src/test/results/clientpositive/llap/vectorized_mapjoin.q.out index 1c72876..8f7ac4d 100644 --- ql/src/test/results/clientpositive/llap/vectorized_mapjoin.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_mapjoin.q.out @@ -74,8 +74,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(col 2) -> bigint, VectorUDAFMaxLong(col 2) -> int, VectorUDAFMinLong(col 2) -> int, VectorUDAFAvgLong(col 12) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgLong(col 12) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash diff --git ql/src/test/results/clientpositive/llap/vectorized_mapjoin2.q.out ql/src/test/results/clientpositive/llap/vectorized_mapjoin2.q.out index 37eb47e..702965d 100644 --- ql/src/test/results/clientpositive/llap/vectorized_mapjoin2.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_mapjoin2.q.out @@ -92,8 +92,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCount(ConstantVectorExpression(val 1) -> 1:long) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] mode: hash outputColumnNames: _col0 @@ -173,8 +175,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFCountMerge(col 0) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 diff --git ql/src/test/results/clientpositive/llap/vectorized_parquet_types.q.out ql/src/test/results/clientpositive/llap/vectorized_parquet_types.q.out index 6cd31db..9984832 100644 --- ql/src/test/results/clientpositive/llap/vectorized_parquet_types.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_parquet_types.q.out @@ -291,9 +291,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMaxLong(col 0) -> int, VectorUDAFMinLong(col 2) -> smallint, VectorUDAFCount(col 5) -> bigint, VectorUDAFAvgDouble(col 3) -> struct, VectorUDAFStdPopDouble(col 4) -> struct, VectorUDAFMaxDecimal(col 10) -> decimal(4,2) className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false keyExpressions: col 1 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgDouble(col 3) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopDouble(col 4) -> struct output type STRUCT requires PRIMITIVE IS false keys: ctinyint (type: tinyint) diff --git ql/src/test/results/clientpositive/llap/vectorized_ptf.q.out ql/src/test/results/clientpositive/llap/vectorized_ptf.q.out index df4b0d8..3f7d584 100644 --- ql/src/test/results/clientpositive/llap/vectorized_ptf.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_ptf.q.out @@ -3319,9 +3319,11 @@ STAGE PLANS: Group By Operator Group By Vectorization: className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true keyExpressions: col 0, col 1, col 2 native: false + vectorProcessingMode: MERGE_PARTIAL projectedOutputColumns: [] keys: KEY._col0 (type: string), KEY._col1 (type: string), KEY._col2 (type: int) mode: mergepartial @@ -3458,9 +3460,11 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumDouble(col 7) -> double className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true keyExpressions: col 2, col 3 native: false + vectorProcessingMode: HASH projectedOutputColumns: [0] keys: p_mfgr (type: string), p_brand (type: string) mode: hash diff --git ql/src/test/results/clientpositive/llap/vectorized_shufflejoin.q.out ql/src/test/results/clientpositive/llap/vectorized_shufflejoin.q.out index 7f04eba..faa7d51 100644 --- ql/src/test/results/clientpositive/llap/vectorized_shufflejoin.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_shufflejoin.q.out @@ -126,8 +126,10 @@ STAGE PLANS: Group By Operator aggregations: count(_col0), max(_col1), min(_col0), avg(_col2) Group By Vectorization: + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: NONE projectedOutputColumns: null mode: hash outputColumnNames: _col0, _col1, _col2, _col3 diff --git ql/src/test/results/clientpositive/llap/vectorized_timestamp_funcs.q.out ql/src/test/results/clientpositive/llap/vectorized_timestamp_funcs.q.out index ed509de..3c975ce 100644 --- ql/src/test/results/clientpositive/llap/vectorized_timestamp_funcs.q.out +++ ql/src/test/results/clientpositive/llap/vectorized_timestamp_funcs.q.out @@ -809,8 +809,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinTimestamp(col 0) -> timestamp, VectorUDAFMaxTimestamp(col 0) -> timestamp, VectorUDAFCount(col 0) -> bigint, VectorUDAFCountStar(*) -> bigint className: VectorGroupByOperator + groupByMode: HASH vectorOutput: true native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3] mode: hash outputColumnNames: _col0, _col1, _col2, _col3 @@ -848,8 +850,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFMinTimestamp(col 0) -> timestamp, VectorUDAFMaxTimestamp(col 1) -> timestamp, VectorUDAFCountMerge(col 2) -> bigint, VectorUDAFCountMerge(col 3) -> bigint className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0, 1, 2, 3] mode: mergepartial outputColumnNames: _col0, _col1, _col2, _col3 @@ -955,8 +959,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFSumDouble(col 0) -> double className: VectorGroupByOperator + groupByMode: MERGEPARTIAL vectorOutput: true native: false + vectorProcessingMode: GLOBAL projectedOutputColumns: [0] mode: mergepartial outputColumnNames: _col0 @@ -1059,8 +1065,10 @@ STAGE PLANS: Group By Vectorization: aggregators: VectorUDAFAvgTimestamp(col 0) -> struct, VectorUDAFVarPopTimestamp(col 0) -> struct, VectorUDAFVarPopTimestamp(col 0) -> struct, VectorUDAFVarSampTimestamp(col 0) -> struct, VectorUDAFStdPopTimestamp(col 0) -> struct, VectorUDAFStdPopTimestamp(col 0) -> struct, VectorUDAFStdPopTimestamp(col 0) -> struct, VectorUDAFStdSampTimestamp(col 0) -> struct className: VectorGroupByOperator + groupByMode: HASH vectorOutput: false native: false + vectorProcessingMode: HASH projectedOutputColumns: [0, 1, 2, 3, 4, 5, 6, 7] vectorOutputConditionsNotMet: Vector output of VectorUDAFAvgTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarPopTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFVarSampTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdPopTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false, Vector output of VectorUDAFStdSampTimestamp(col 0) -> struct output type STRUCT requires PRIMITIVE IS false mode: hash diff --git vector-code-gen/src/org/apache/hadoop/hive/tools/GenVectorCode.java vector-code-gen/src/org/apache/hadoop/hive/tools/GenVectorCode.java index 926321e..b44105e 100644 --- vector-code-gen/src/org/apache/hadoop/hive/tools/GenVectorCode.java +++ vector-code-gen/src/org/apache/hadoop/hive/tools/GenVectorCode.java @@ -24,6 +24,11 @@ import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashSet; +import java.util.List; +import java.util.Set; import org.apache.tools.ant.BuildException; import org.apache.tools.ant.Task; @@ -1004,11 +1009,32 @@ {"VectorUDAFMinMaxIntervalDayTime", "VectorUDAFMinIntervalDayTime", ">", "min", "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: interval_day_time)"}, - //template, , - {"VectorUDAFSum", "VectorUDAFSumLong", "long"}, - {"VectorUDAFSum", "VectorUDAFSumDouble", "double"}, - {"VectorUDAFAvg", "VectorUDAFAvgLong", "long"}, - {"VectorUDAFAvg", "VectorUDAFAvgDouble", "double"}, + // Template, , + {"VectorUDAFSum", "VectorUDAFSumLong", "long"}, + {"VectorUDAFSum", "VectorUDAFSumDouble", "double"}, + + // Template, , , + {"VectorUDAFAvg", "VectorUDAFAvgLong", "long", "PARTIAL1"}, + {"VectorUDAFAvg", "VectorUDAFAvgLongComplete", "long", "COMPLETE"}, + + {"VectorUDAFAvg", "VectorUDAFAvgDouble", "double", "PARTIAL1"}, + {"VectorUDAFAvg", "VectorUDAFAvgDoubleComplete", "double", "COMPLETE"}, + + {"VectorUDAFAvgDecimal", "VectorUDAFAvgDecimal", "PARTIAL1"}, + {"VectorUDAFAvgDecimal", "VectorUDAFAvgDecimalComplete", "COMPLETE"}, + + {"VectorUDAFAvgTimestamp", "VectorUDAFAvgTimestamp", "PARTIAL1"}, + {"VectorUDAFAvgTimestamp", "VectorUDAFAvgTimestampComplete", "COMPLETE"}, + + //template, , , + {"VectorUDAFAvgMerge", "VectorUDAFAvgPartial2", "PARTIAL2"}, + {"VectorUDAFAvgMerge", "VectorUDAFAvgFinal", "FINAL"}, + + {"VectorUDAFAvgDecimalMerge", "VectorUDAFAvgDecimalPartial2", "PARTIAL2"}, + {"VectorUDAFAvgDecimalMerge", "VectorUDAFAvgDecimalFinal", "FINAL"}, + + // (since Timestamps are averaged with double, we don't need a separate PARTIAL2 class) + {"VectorUDAFAvgMerge", "VectorUDAFAvgTimestampFinal", "FINAL,TIMESTAMP"}, // template, , , , , // @@ -1204,6 +1230,14 @@ private void generate() throws Exception { generateVectorUDAFSum(tdesc); } else if (tdesc[0].equals("VectorUDAFAvg")) { generateVectorUDAFAvg(tdesc); + } else if (tdesc[0].equals("VectorUDAFAvgMerge")) { + generateVectorUDAFAvgMerge(tdesc); + } else if (tdesc[0].equals("VectorUDAFAvgDecimal")) { + generateVectorUDAFAvgObject(tdesc); + } else if (tdesc[0].equals("VectorUDAFAvgTimestamp")) { + generateVectorUDAFAvgObject(tdesc); + } else if (tdesc[0].equals("VectorUDAFAvgDecimalMerge")) { + generateVectorUDAFAvgMerge(tdesc); } else if (tdesc[0].equals("VectorUDAFVar")) { generateVectorUDAFVar(tdesc); } else if (tdesc[0].equals("VectorUDAFVarDecimal")) { @@ -1566,6 +1600,7 @@ private void generateVectorUDAFAvg(String[] tdesc) throws Exception { String className = tdesc[1]; String valueType = tdesc[2]; String columnType = getColumnVectorType(valueType); + String ifDefined = tdesc[3]; File templateFile = new File(joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt")); @@ -1573,6 +1608,39 @@ private void generateVectorUDAFAvg(String[] tdesc) throws Exception { templateString = templateString.replaceAll("", className); templateString = templateString.replaceAll("", valueType); templateString = templateString.replaceAll("", columnType); + + templateString = evaluateIfDefined(templateString, ifDefined); + + writeFile(templateFile.lastModified(), udafOutputDirectory, udafClassesDirectory, + className, templateString); + } + + private void generateVectorUDAFAvgMerge(String[] tdesc) throws Exception { + String className = tdesc[1]; + String groupByMode = tdesc[2]; + + File templateFile = new File(joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt")); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + + templateString = evaluateIfDefined(templateString, groupByMode); + + writeFile(templateFile.lastModified(), udafOutputDirectory, udafClassesDirectory, + className, templateString); + } + + private void generateVectorUDAFAvgObject(String[] tdesc) throws Exception { + String className = tdesc[1]; + String ifDefined = tdesc[2]; + + File templateFile = new File(joinPath(this.udafTemplateDirectory, tdesc[0] + ".txt")); + + String templateString = readFile(templateFile); + templateString = templateString.replaceAll("", className); + + templateString = evaluateIfDefined(templateString, ifDefined); + writeFile(templateFile.lastModified(), udafOutputDirectory, udafClassesDirectory, className, templateString); } @@ -3126,6 +3194,107 @@ private static boolean isTimestampIntervalType(String type) { || type.equals("interval_day_time")); } + private boolean containsDefinedStrings(Set defineSet, String commaDefinedString) { + String[] definedStrings = commaDefinedString.split(","); + boolean result = false; + for (String definedString : definedStrings) { + if (defineSet.contains(definedString)) { + result = true; + break; + } + } + return result; + } + + private int doIfDefinedStatement(String[] lines, int index, Set definedSet, + boolean outerInclude, StringBuilder sb) { + String ifLine = lines[index]; + final int ifLineNumber = index + 1; + String commaDefinedString = ifLine.substring("#IF ".length()); + boolean includeBody = containsDefinedStrings(definedSet, commaDefinedString); + index++; + final int end = lines.length; + while (true) { + if (index >= end) { + throw new RuntimeException("Unmatched #IF at line " + index + " for " + commaDefinedString); + } + String line = lines[index]; + if (line.length() == 0 || line.charAt(0) != '#') { + if (outerInclude && includeBody) { + sb.append(line); + sb.append("\n"); + } + index++; + continue; + } + + // A pound # statement (IF/ELSE/ENDIF). + if (line.startsWith("#IF ")) { + // Recurse. + index = doIfDefinedStatement(lines, index, definedSet, outerInclude && includeBody, sb); + } else if (line.equals("#ELSE")) { + // Flip inclusion. + includeBody = !includeBody; + index++; + } else if (line.equals("#ENDIF")) { + throw new RuntimeException("Missing defined strings with #ENDIF on line " + (index + 1)); + } else if (line.startsWith("#ENDIF ")) { + String endCommaDefinedString = line.substring("#ENDIF ".length()); + if (!commaDefinedString.equals(endCommaDefinedString)) { + throw new RuntimeException( + "#ENDIF defined names \"" + endCommaDefinedString + "\" (line " + ifLineNumber + + " do not match \"" + commaDefinedString + "\" (line " + (index + 1) + ")"); + } + return ++index; + } else { + throw new RuntimeException("Problem with #IF/#ELSE/#ENDIF on line " + (index + 1) + ": " + line); + } + } + } + + private void doEvaluateIfDefined(String[] lines, int index, Set definedSet, + boolean outerInclude, StringBuilder sb) { + final int end = lines.length; + while (true) { + if (index >= end) { + break; + } + String line = lines[index]; + if (line.length() == 0 || line.charAt(0) != '#') { + if (outerInclude) { + sb.append(line); + sb.append("\n"); + } + index++; + continue; + } + + // A pound # statement (IF/ELSE/ENDIF). + if (line.startsWith("#IF ")) { + index = doIfDefinedStatement(lines, index, definedSet, outerInclude, sb); + } else { + throw new RuntimeException("Problem with #IF/#ELSE/#ENDIF on line " + (index + 1) + ": " + line); + } + } + } + + private String evaluateIfDefined(String linesString, List definedList) { + String[] lines = linesString.split("\n"); + Set definedSet = new HashSet(definedList); + StringBuilder sb = new StringBuilder(); + doEvaluateIfDefined(lines, 0, definedSet, true, sb); + return sb.toString(); + } + + private String evaluateIfDefined(String linesString, String definedString) { + String[] lines = linesString.split("\n"); + List definedList = new ArrayList(Arrays.asList(definedString.split(","))); + Set definedSet = new HashSet(definedList); + StringBuilder sb = new StringBuilder(); + doEvaluateIfDefined(lines, 0, definedSet, true, sb); + return sb.toString(); + } + static void writeFile(long templateTime, String outputDir, String classesDir, String className, String str) throws IOException { File outputFile = new File(outputDir, className + ".java");