diff --git itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/AbstractExpression.java itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/AbstractExpression.java
index 94af3e0..0f6d943 100644
--- itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/AbstractExpression.java
+++ itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/AbstractExpression.java
@@ -37,7 +37,8 @@
@State(Scope.Thread)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
public abstract class AbstractExpression {
- private static final int DEFAULT_ITER_TIME = 1000000;
+ protected static final int DEFAULT_ITER_TIME = 1000000;
+ protected int iterTime = DEFAULT_ITER_TIME;
protected VectorExpression expression;
protected VectorizedRowBatch rowBatch;
@@ -58,7 +59,7 @@ protected VectorizedRowBatch buildRowBatch(ColumnVector output, int colNum, Colu
@Warmup(iterations = 2, time = 2, timeUnit = TimeUnit.MILLISECONDS)
@Measurement(iterations = 2, time = 2, timeUnit = TimeUnit.MILLISECONDS)
public void bench() {
- for (int i = 0; i < DEFAULT_ITER_TIME; i++) {
+ for (int i = 0; i < iterTime; i++) {
expression.evaluate(rowBatch);
}
}
diff --git itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColAddDecimalColumnOld.java itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColAddDecimalColumnOld.java
new file mode 100644
index 0000000..8cc332c
--- /dev/null
+++ itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColAddDecimalColumnOld.java
@@ -0,0 +1,157 @@
+package org.apache.hive.benchmark.vectorization;
+
+import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+
+public class DecimalColAddDecimalColumnOld extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private int colNum1;
+ private int colNum2;
+ private int outputColumn;
+
+ public DecimalColAddDecimalColumnOld(int colNum1, int colNum2, int outputColumn) {
+ this.colNum1 = colNum1;
+ this.colNum2 = colNum2;
+ this.outputColumn = outputColumn;
+ this.outputType = "decimal";
+ }
+
+ public DecimalColAddDecimalColumnOld() {
+ this.outputType = "decimal";
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) {
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector1 = (DecimalColumnVector) batch.cols[colNum1];
+ DecimalColumnVector inputColVector2 = (DecimalColumnVector) batch.cols[colNum2];
+ DecimalColumnVector outputColVector = (DecimalColumnVector) batch.cols[outputColumn];
+ int[] sel = batch.selected;
+ int n = batch.size;
+
+ // return immediately if batch is empty
+ if (n == 0) {
+ return;
+ }
+
+ outputColVector.isRepeating =
+ inputColVector1.isRepeating && inputColVector2.isRepeating
+ || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
+ || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
+
+ if (inputColVector1.noNulls && inputColVector2.noNulls) {
+
+ /* Initialize output vector NULL values to false. This is necessary
+ * since the decimal operation may produce a NULL result even for
+ * a non-null input vector value, and convert the output vector
+ * to have noNulls = false;
+ */
+ NullUtil.initOutputNullsToFalse(outputColVector,
+ inputColVector1.isRepeating && inputColVector2.isRepeating,
+ batch.selectedInUse, sel, n);
+ }
+
+ // Handle nulls first
+ NullUtil.propagateNullsColCol(
+ inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
+
+ /* Disregard nulls for processing. In other words,
+ * the arithmetic operation is performed even if one or
+ * more inputs are null. This is to improve speed by avoiding
+ * conditional checks in the inner loop.
+ */
+ if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
+ DecimalUtil.addChecked(0, inputColVector1.get(0), inputColVector2.get(0), outputColVector);
+ } else if (inputColVector1.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.addChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.addChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ }
+ } else if (inputColVector2.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.addChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.addChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ }
+ } else {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.addChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.addChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ }
+ }
+
+ /* For the case when the output can have null values, follow
+ * the convention that the data values must be set to a specific non-zero
+ * value. This is to prevent possible later zero-divide errors
+ * in complex arithmetic expressions like col2 / (col1 - 1)
+ * in the case when some col1 entries are null.
+ */
+ NullUtil.setNullDataEntriesDecimal(outputColVector, batch.selectedInUse, sel, n);
+ }
+
+ @Override
+ public int getOutputColumn() {
+ return outputColumn;
+ }
+
+ public int getColNum1() {
+ return colNum1;
+ }
+
+ public void setColNum1(int colNum1) {
+ this.colNum1 = colNum1;
+ }
+
+ public int getColNum2() {
+ return colNum2;
+ }
+
+ public void setColNum2(int colNum2) {
+ this.colNum2 = colNum2;
+ }
+
+ public void setOutputColumn(int outputColumn) {
+ this.outputColumn = outputColumn;
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"),
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"))
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
diff --git itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColDivideDecimalColumnOld.java itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColDivideDecimalColumnOld.java
new file mode 100644
index 0000000..b6ee9b7
--- /dev/null
+++ itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColDivideDecimalColumnOld.java
@@ -0,0 +1,129 @@
+package org.apache.hive.benchmark.vectorization;
+
+import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+
+public class DecimalColDivideDecimalColumnOld extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private int colNum1;
+ private int colNum2;
+ private int outputColumn;
+
+ public DecimalColDivideDecimalColumnOld(int colNum1, int colNum2, int outputColumn) {
+ this.colNum1 = colNum1;
+ this.colNum2 = colNum2;
+ this.outputColumn = outputColumn;
+ this.outputType = "decimal";
+ }
+
+ public DecimalColDivideDecimalColumnOld() {
+ this.outputType = "decimal";
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) {
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector1 = (DecimalColumnVector) batch.cols[colNum1];
+ DecimalColumnVector inputColVector2 = (DecimalColumnVector) batch.cols[colNum2];
+ DecimalColumnVector outputColVector = (DecimalColumnVector) batch.cols[outputColumn];
+ int[] sel = batch.selected;
+ int n = batch.size;
+
+ // return immediately if batch is empty
+ if (n == 0) {
+ return;
+ }
+
+ outputColVector.isRepeating =
+ inputColVector1.isRepeating && inputColVector2.isRepeating
+ || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
+ || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
+
+ if (inputColVector1.noNulls && inputColVector2.noNulls) {
+
+ /* Initialize output vector NULL values to false. This is necessary
+ * since the decimal operation may produce a NULL result even for
+ * a non-null input vector value, and convert the output vector
+ * to have noNulls = false;
+ */
+ NullUtil.initOutputNullsToFalse(outputColVector,
+ inputColVector1.isRepeating && inputColVector2.isRepeating,
+ batch.selectedInUse, sel, n);
+ }
+
+ // Handle nulls first
+ NullUtil.propagateNullsColCol(
+ inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
+
+ /* Disregard nulls for processing. In other words,
+ * the arithmetic operation is performed even if one or
+ * more inputs are null. This is to improve speed by avoiding
+ * conditional checks in the inner loop.
+ */
+ if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
+ DecimalUtil.divideChecked(0, inputColVector1.get(0), inputColVector2.get(0), outputColVector);
+ } else if (inputColVector1.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.divideChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.divideChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ }
+ } else if (inputColVector2.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.divideChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.divideChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ }
+ } else {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.divideChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.divideChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ }
+ }
+ }
+
+ @Override
+ public int getOutputColumn() {
+ return outputColumn;
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"),
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"))
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
diff --git itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColMultiplyDecimalColumnOld.java itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColMultiplyDecimalColumnOld.java
new file mode 100644
index 0000000..0e6a013
--- /dev/null
+++ itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColMultiplyDecimalColumnOld.java
@@ -0,0 +1,157 @@
+package org.apache.hive.benchmark.vectorization;
+
+import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+
+public class DecimalColMultiplyDecimalColumnOld extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private int colNum1;
+ private int colNum2;
+ private int outputColumn;
+
+ public DecimalColMultiplyDecimalColumnOld(int colNum1, int colNum2, int outputColumn) {
+ this.colNum1 = colNum1;
+ this.colNum2 = colNum2;
+ this.outputColumn = outputColumn;
+ this.outputType = "decimal";
+ }
+
+ public DecimalColMultiplyDecimalColumnOld() {
+ this.outputType = "decimal";
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) {
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector1 = (DecimalColumnVector) batch.cols[colNum1];
+ DecimalColumnVector inputColVector2 = (DecimalColumnVector) batch.cols[colNum2];
+ DecimalColumnVector outputColVector = (DecimalColumnVector) batch.cols[outputColumn];
+ int[] sel = batch.selected;
+ int n = batch.size;
+
+ // return immediately if batch is empty
+ if (n == 0) {
+ return;
+ }
+
+ outputColVector.isRepeating =
+ inputColVector1.isRepeating && inputColVector2.isRepeating
+ || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
+ || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
+
+ if (inputColVector1.noNulls && inputColVector2.noNulls) {
+
+ /* Initialize output vector NULL values to false. This is necessary
+ * since the decimal operation may produce a NULL result even for
+ * a non-null input vector value, and convert the output vector
+ * to have noNulls = false;
+ */
+ NullUtil.initOutputNullsToFalse(outputColVector,
+ inputColVector1.isRepeating && inputColVector2.isRepeating,
+ batch.selectedInUse, sel, n);
+ }
+
+ // Handle nulls first
+ NullUtil.propagateNullsColCol(
+ inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
+
+ /* Disregard nulls for processing. In other words,
+ * the arithmetic operation is performed even if one or
+ * more inputs are null. This is to improve speed by avoiding
+ * conditional checks in the inner loop.
+ */
+ if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
+ DecimalUtil.multiplyChecked(0, inputColVector1.get(0), inputColVector2.get(0), outputColVector);
+ } else if (inputColVector1.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.multiplyChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.multiplyChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ }
+ } else if (inputColVector2.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.multiplyChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.multiplyChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ }
+ } else {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.multiplyChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.multiplyChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ }
+ }
+
+ /* For the case when the output can have null values, follow
+ * the convention that the data values must be set to a specific non-zero
+ * value. This is to prevent possible later zero-divide errors
+ * in complex arithmetic expressions like col2 / (col1 - 1)
+ * in the case when some col1 entries are null.
+ */
+ NullUtil.setNullDataEntriesDecimal(outputColVector, batch.selectedInUse, sel, n);
+ }
+
+ @Override
+ public int getOutputColumn() {
+ return outputColumn;
+ }
+
+ public int getColNum1() {
+ return colNum1;
+ }
+
+ public void setColNum1(int colNum1) {
+ this.colNum1 = colNum1;
+ }
+
+ public int getColNum2() {
+ return colNum2;
+ }
+
+ public void setColNum2(int colNum2) {
+ this.colNum2 = colNum2;
+ }
+
+ public void setOutputColumn(int outputColumn) {
+ this.outputColumn = outputColumn;
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"),
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"))
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
diff --git itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColSubtractDecimalColumnOld.java itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColSubtractDecimalColumnOld.java
new file mode 100644
index 0000000..9006b3b
--- /dev/null
+++ itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/DecimalColSubtractDecimalColumnOld.java
@@ -0,0 +1,157 @@
+package org.apache.hive.benchmark.vectorization;
+
+import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+
+public class DecimalColSubtractDecimalColumnOld extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private int colNum1;
+ private int colNum2;
+ private int outputColumn;
+
+ public DecimalColSubtractDecimalColumnOld(int colNum1, int colNum2, int outputColumn) {
+ this.colNum1 = colNum1;
+ this.colNum2 = colNum2;
+ this.outputColumn = outputColumn;
+ this.outputType = "decimal";
+ }
+
+ public DecimalColSubtractDecimalColumnOld() {
+ this.outputType = "decimal";
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) {
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector1 = (DecimalColumnVector) batch.cols[colNum1];
+ DecimalColumnVector inputColVector2 = (DecimalColumnVector) batch.cols[colNum2];
+ DecimalColumnVector outputColVector = (DecimalColumnVector) batch.cols[outputColumn];
+ int[] sel = batch.selected;
+ int n = batch.size;
+
+ // return immediately if batch is empty
+ if (n == 0) {
+ return;
+ }
+
+ outputColVector.isRepeating =
+ inputColVector1.isRepeating && inputColVector2.isRepeating
+ || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
+ || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
+
+ if (inputColVector1.noNulls && inputColVector2.noNulls) {
+
+ /* Initialize output vector NULL values to false. This is necessary
+ * since the decimal operation may produce a NULL result even for
+ * a non-null input vector value, and convert the output vector
+ * to have noNulls = false;
+ */
+ NullUtil.initOutputNullsToFalse(outputColVector,
+ inputColVector1.isRepeating && inputColVector2.isRepeating,
+ batch.selectedInUse, sel, n);
+ }
+
+ // Handle nulls first
+ NullUtil.propagateNullsColCol(
+ inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
+
+ /* Disregard nulls for processing. In other words,
+ * the arithmetic operation is performed even if one or
+ * more inputs are null. This is to improve speed by avoiding
+ * conditional checks in the inner loop.
+ */
+ if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
+ DecimalUtil.subtractChecked(0, inputColVector1.get(0), inputColVector2.get(0), outputColVector);
+ } else if (inputColVector1.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.subtractChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.subtractChecked(i, inputColVector1.get(0), inputColVector2.get(i), outputColVector);
+ }
+ }
+ } else if (inputColVector2.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.subtractChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.subtractChecked(i, inputColVector1.get(i), inputColVector2.get(0), outputColVector);
+ }
+ }
+ } else {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ DecimalUtil.subtractChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ DecimalUtil.subtractChecked(i, inputColVector1.get(i), inputColVector2.get(i), outputColVector);
+ }
+ }
+ }
+
+ /* For the case when the output can have null values, follow
+ * the convention that the data values must be set to a specific non-zero
+ * value. This is to prevent possible later zero-divide errors
+ * in complex arithmetic expressions like col2 / (col1 - 1)
+ * in the case when some col1 entries are null.
+ */
+ NullUtil.setNullDataEntriesDecimal(outputColVector, batch.selectedInUse, sel, n);
+ }
+
+ @Override
+ public int getOutputColumn() {
+ return outputColumn;
+ }
+
+ public int getColNum1() {
+ return colNum1;
+ }
+
+ public void setColNum1(int colNum1) {
+ this.colNum1 = colNum1;
+ }
+
+ public int getColNum2() {
+ return colNum2;
+ }
+
+ public void setColNum2(int colNum2) {
+ this.colNum2 = colNum2;
+ }
+
+ public void setOutputColumn(int outputColumn) {
+ this.outputColumn = outputColumn;
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"),
+ VectorExpressionDescriptor.ArgumentType.getType("decimal"))
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
diff --git itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedDecimalBench.java itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedDecimalBench.java
new file mode 100644
index 0000000..5cb99fc
--- /dev/null
+++ itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedDecimalBench.java
@@ -0,0 +1,275 @@
+/**
+ * Licensed 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.hive.benchmark.vectorization;
+
+import org.apache.hadoop.hive.common.type.HiveDecimal;
+import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.*;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColAddDecimalColumn;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColDivideDecimalColumn;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColMultiplyDecimalColumn;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.DecimalColSubtractDecimalColumn;
+import org.openjdk.jmh.annotations.*;
+import org.openjdk.jmh.runner.Runner;
+import org.openjdk.jmh.runner.RunnerException;
+import org.openjdk.jmh.runner.options.Options;
+import org.openjdk.jmh.runner.options.OptionsBuilder;
+
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * This test measures the performance for vectorization.
+ *
+ * This test uses JMH framework for benchmarking.
+ * You may execute this benchmark tool using JMH command line in different ways:
+ *
+ * To use the settings shown in the main() function, use:
+ * $ java -cp target/benchmarks.jar org.apache.hive.benchmark.vectorization.VectorizedArithmeticBench
+ *
+ * To use the default settings used by JMH, use:
+ * $ java -jar target/benchmarks.jar org.apache.hive.benchmark.vectorization.VectorizedArithmeticBench
+ *
+ * To specify different parameters, use:
+ * - This command will use 10 warm-up iterations, 5 test iterations, and 2 forks. And it will
+ * display the Average Time (avgt) in Microseconds (us)
+ * - Benchmark mode. Available modes are:
+ * [Throughput/thrpt, AverageTime/avgt, SampleTime/sample, SingleShotTime/ss, All/all]
+ * - Output time unit. Available time units are: [m, s, ms, us, ns].
+ *
+ * $ java -jar target/benchmarks.jar org.apache.hive.benchmark.vectorization.VectorizedDecimalBench
+ * -wi 10 -i 5 -f 2 -bm avgt -tu us
+ */
+@State(Scope.Benchmark)
+public class VectorizedDecimalBench {
+
+ @BenchmarkMode(Mode.AverageTime)
+ @Fork(1)
+ @State(Scope.Thread)
+ @OutputTimeUnit(TimeUnit.NANOSECONDS)
+ private static abstract class AbstractDecimalExpression extends AbstractExpression {
+ private boolean firstRun = true;
+
+ @Override
+ @Measurement(iterations = 5, time = 5, timeUnit = TimeUnit.MILLISECONDS)
+ public void bench() {
+ if (firstRun) {
+ iterTime = DEFAULT_ITER_TIME;
+ rowBatch.size = 1;
+ rowBatch.ensureSize(1);
+ } else {
+ iterTime = 1;
+ rowBatch.size = VectorizedRowBatch.DEFAULT_SIZE;
+ rowBatch.ensureSize(VectorizedRowBatch.DEFAULT_SIZE);
+ }
+ firstRun = false;
+ super.bench();
+ }
+ }
+
+ private static DecimalColumnVector getDecimalColumnVector(int precision, int scale) {
+ DecimalColumnVector vector = new DecimalColumnVector(precision, scale);
+ StringBuilder builder = new StringBuilder();
+ Random random = new Random();
+ for (int i = 0; i < precision - scale; i++) {
+ builder.append(random.nextInt(10));
+ }
+ String string = builder.toString();
+ for (int i = 0; i < VectorizedRowBatch.DEFAULT_SIZE; i++) {
+ HiveDecimal hiveDecimal = HiveDecimal.create(string);
+ vector.set(i, hiveDecimal);
+ }
+ return vector;
+ }
+
+ public static class DecimalColAdd64ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(11, 2), 2,
+ getDecimalColumnVector(10, 2), getDecimalColumnVector(10, 2));
+ expression = new DecimalColAddDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColAdd128ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(21, 2), 2,
+ getDecimalColumnVector(20, 2), getDecimalColumnVector(20, 2));
+ expression = new DecimalColAddDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColAdd64ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(11, 2), 2,
+ getDecimalColumnVector(10, 2), getDecimalColumnVector(10, 2));
+ expression = new DecimalColAddDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColAdd128ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(21, 2), 2,
+ getDecimalColumnVector(20, 2), getDecimalColumnVector(20, 2));
+ expression = new DecimalColAddDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColSub64ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(21, 2), 2,
+ getDecimalColumnVector(10, 2), getDecimalColumnVector(10, 2));
+ expression = new DecimalColSubtractDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColSub128ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(21, 2), 2,
+ getDecimalColumnVector(20, 2), getDecimalColumnVector(20, 2));
+ expression = new DecimalColSubtractDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColSub64ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(21, 2), 2,
+ getDecimalColumnVector(10, 2), getDecimalColumnVector(10, 2));
+ expression = new DecimalColSubtractDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColSub128ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(21, 2), 2,
+ getDecimalColumnVector(20, 2), getDecimalColumnVector(20, 2));
+ expression = new DecimalColSubtractDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColDiv64ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(20, 2), 2,
+ getDecimalColumnVector(4, 0), getDecimalColumnVector(2, 0));
+ expression = new DecimalColDivideDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColDiv128ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(20, 2), 2,
+ getDecimalColumnVector(20, 0), getDecimalColumnVector(10, 0));
+ expression = new DecimalColDivideDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColDiv128By16ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(20, 2), 2,
+ getDecimalColumnVector(20, 0), getDecimalColumnVector(4, 0));
+ expression = new DecimalColDivideDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColDiv64ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(20, 2), 2,
+ getDecimalColumnVector(4, 0), getDecimalColumnVector(2, 0));
+ expression = new DecimalColDivideDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColDiv128ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(20, 2), 2,
+ getDecimalColumnVector(20, 0), getDecimalColumnVector(10, 0));
+ expression = new DecimalColDivideDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColDiv128By16ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(20, 2), 2,
+ getDecimalColumnVector(20, 0), getDecimalColumnVector(4, 0));
+ expression = new DecimalColDivideDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColMul64ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(11, 4), 2,
+ getDecimalColumnVector(5, 2), getDecimalColumnVector(5, 2));
+ expression = new DecimalColMultiplyDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColMul128ColNewBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(31, 4), 2,
+ getDecimalColumnVector(15, 2), getDecimalColumnVector(15, 2));
+ expression = new DecimalColMultiplyDecimalColumn(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColMul64ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(11, 4), 2,
+ getDecimalColumnVector(5, 2), getDecimalColumnVector(5, 2));
+ expression = new DecimalColMultiplyDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalColMul128ColOldBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new DecimalColumnVector(31, 4), 2,
+ getDecimalColumnVector(15, 2), getDecimalColumnVector(15, 2));
+ expression = new DecimalColMultiplyDecimalColumnOld(0, 1, 2);
+ }
+ }
+
+ public static class DecimalToString128ColBench extends AbstractDecimalExpression {
+ @Override
+ public void setup() {
+ rowBatch = buildRowBatch(new BytesColumnVector(), 1,
+ getDecimalColumnVector(20, 2));
+ expression = new CastDecimalToString(0, 1);
+ }
+ }
+
+ public static void main(String[] args) throws RunnerException {
+ Options opt = new OptionsBuilder().include(".*" + VectorizedDecimalBench.class.getSimpleName() +
+ ".*").build();
+ new Runner(opt).run();
+ }
+}
diff --git orc/src/java/org/apache/orc/impl/ConvertTreeReaderFactory.java orc/src/java/org/apache/orc/impl/ConvertTreeReaderFactory.java
index 5d5f991..e4348d8 100644
--- orc/src/java/org/apache/orc/impl/ConvertTreeReaderFactory.java
+++ orc/src/java/org/apache/orc/impl/ConvertTreeReaderFactory.java
@@ -613,7 +613,7 @@ public void nextVector(ColumnVector previousVector,
@Override
public void setConvertVectorElement(int elementNum) throws IOException {
- HiveDecimal decimalValue = decimalColVector.vector[elementNum].getHiveDecimal();
+ HiveDecimal decimalValue = decimalColVector.hiveDecimal(elementNum);
if (decimalValue.compareTo(DECIMAL_MAX_LONG) > 0 ||
decimalValue.compareTo(DECIMAL_MIN_LONG) < 0) {
longColVector.isNull[elementNum] = true;
@@ -828,7 +828,7 @@ public void nextVector(ColumnVector previousVector,
@Override
public void setConvertVectorElement(int elementNum) throws IOException {
doubleColVector.vector[elementNum] =
- (float) decimalColVector.vector[elementNum].getHiveDecimal().doubleValue();
+ (float) decimalColVector.hiveDecimal(elementNum).floatValue();
}
@Override
@@ -1034,7 +1034,7 @@ public void nextVector(ColumnVector previousVector,
@Override
public void setConvertVectorElement(int elementNum) throws IOException {
doubleColVector.vector[elementNum] =
- decimalColVector.vector[elementNum].getHiveDecimal().doubleValue();
+ decimalColVector.hiveDecimal(elementNum).doubleValue();
}
@Override
@@ -1372,7 +1372,7 @@ public void nextVector(ColumnVector previousVector,
public void setConvertVectorElement(int elementNum) throws IOException {
HiveDecimalWritable valueWritable = HiveDecimalWritable.enforcePrecisionScale(
- fileDecimalColVector.vector[elementNum], readerPrecision, readerScale);
+ fileDecimalColVector.get(elementNum), readerPrecision, readerScale);
if (valueWritable != null) {
decimalColVector.set(elementNum, valueWritable);
} else {
@@ -1553,7 +1553,7 @@ public void nextVector(ColumnVector previousVector,
@Override
public void setConvertVectorElement(int elementNum) {
- String string = decimalColVector.vector[elementNum].getHiveDecimal().toString();
+ String string = decimalColVector.hiveDecimal(elementNum).toString();
byte[] bytes = string.getBytes();
assignStringGroupVectorEntry(bytesColVector, elementNum, readerType, bytes);
}
@@ -1888,7 +1888,7 @@ public void nextVector(ColumnVector previousVector,
public void setConvertVectorElement(int elementNum) {
Timestamp timestampValue =
TimestampUtils.decimalToTimestamp(
- decimalColVector.vector[elementNum].getHiveDecimal());
+ decimalColVector.hiveDecimal(elementNum));
// The TimestampColumnVector will set the entry to null when a null timestamp is passed in.
timestampColVector.set(elementNum, timestampValue);
}
diff --git orc/src/java/org/apache/orc/impl/WriterImpl.java orc/src/java/org/apache/orc/impl/WriterImpl.java
index b2966e0..9e3fe9d 100644
--- orc/src/java/org/apache/orc/impl/WriterImpl.java
+++ orc/src/java/org/apache/orc/impl/WriterImpl.java
@@ -1907,7 +1907,7 @@ void writeBatch(ColumnVector vector, int offset,
DecimalColumnVector vec = (DecimalColumnVector) vector;
if (vector.isRepeating) {
if (vector.noNulls || !vector.isNull[0]) {
- HiveDecimal value = vec.vector[0].getHiveDecimal();
+ HiveDecimal value = vec.hiveDecimal(0);
indexStatistics.updateDecimal(value);
if (createBloomFilter) {
bloomFilter.addString(value.toString());
@@ -1921,7 +1921,7 @@ void writeBatch(ColumnVector vector, int offset,
} else {
for(int i=0; i < length; ++i) {
if (vec.noNulls || !vec.isNull[i + offset]) {
- HiveDecimal value = vec.vector[i + offset].getHiveDecimal();
+ HiveDecimal value = vec.hiveDecimal(i + offset);
SerializationUtils.writeBigInteger(valueStream,
value.unscaledValue());
scaleStream.write(value.scale());
diff --git orc/src/java/org/apache/orc/tools/FileDump.java orc/src/java/org/apache/orc/tools/FileDump.java
index 1a1d8ab..697bae5 100644
--- orc/src/java/org/apache/orc/tools/FileDump.java
+++ orc/src/java/org/apache/orc/tools/FileDump.java
@@ -872,7 +872,7 @@ static void printValue(JSONWriter writer, ColumnVector vector,
printBinary(writer, (BytesColumnVector) vector, row);
break;
case DECIMAL:
- writer.value(((DecimalColumnVector) vector).vector[row].toString());
+ writer.value(((DecimalColumnVector) vector).hiveDecimal(row).toString());
break;
case DATE:
writer.value(new DateWritable(
diff --git orc/src/test/org/apache/orc/TestVectorOrcFile.java orc/src/test/org/apache/orc/TestVectorOrcFile.java
index 112edb9..f5f2cfb 100644
--- orc/src/test/org/apache/orc/TestVectorOrcFile.java
+++ orc/src/test/org/apache/orc/TestVectorOrcFile.java
@@ -284,7 +284,7 @@ public void testReadFormat_0_11() throws Exception {
assertEquals(Timestamp.valueOf("2000-03-12 15:00:00"),
timestamp.asScratchTimestamp(0));
assertEquals(new HiveDecimalWritable(HiveDecimal.create("12345678.6547456")),
- decs.vector[0]);
+ decs.get(0));
// check the contents of row 7499
rows.seekToRow(7499);
@@ -324,7 +324,7 @@ public void testReadFormat_0_11() throws Exception {
assertEquals(Timestamp.valueOf("2000-03-12 15:00:01"),
timestamp.asScratchTimestamp(0));
assertEquals(new HiveDecimalWritable(HiveDecimal.create("12345678.6547457")),
- decs.vector[0]);
+ decs.get(0));
// handle the close up
Assert.assertEquals(false, rows.nextBatch(batch));
@@ -1396,7 +1396,7 @@ private static void setUnion(VectorizedRowBatch batch, int rowId,
batch.cols[1].noNulls = false;
}
if (dec != null) {
- ((DecimalColumnVector) batch.cols[2]).vector[rowId] = dec;
+ ((DecimalColumnVector) batch.cols[2]).set(rowId, dec);
} else {
batch.cols[2].isNull[rowId] = true;
batch.cols[2].noNulls = false;
@@ -1542,12 +1542,12 @@ public void testUnionAndTimestamp() throws Exception {
assertEquals("2000-03-12 15:00:00.0", ts.asScratchTimestamp(0).toString());
assertEquals(0, union.tags[0]);
assertEquals(42, longs.vector[0]);
- assertEquals("12345678.6547456", decs.vector[0].toString());
+ assertEquals("12345678.6547456", decs.hiveDecimal(0).toString());
assertEquals("2000-03-20 12:00:00.123456789", ts.asScratchTimestamp(1).toString());
assertEquals(1, union.tags[1]);
assertEquals("hello", strs.toString(1));
- assertEquals("-5643.234", decs.vector[1].toString());
+ assertEquals("-5643.234", decs.hiveDecimal(1).toString());
assertEquals(false, ts.noNulls);
assertEquals(false, union.noNulls);
@@ -1575,7 +1575,7 @@ public void testUnionAndTimestamp() throws Exception {
assertEquals(false, longs.isNull[5]);
assertEquals(200000, longs.vector[5]);
assertEquals(false, decs.isNull[5]);
- assertEquals("10000000000000000000", decs.vector[5].toString());
+ assertEquals("10000000000000000000", decs.hiveDecimal(5).toString());
rand = new Random(42);
for(int i=1970; i < 2038; ++i) {
@@ -1590,7 +1590,7 @@ public void testUnionAndTimestamp() throws Exception {
assertEquals(Integer.toString(i * i), strs.toString(row));
}
assertEquals(new HiveDecimalWritable(HiveDecimal.create(new BigInteger(64, rand),
- rand.nextInt(18))), decs.vector[row]);
+ rand.nextInt(18))), decs.get(row));
}
// rebuild the row batch, so that we can read by 1000 rows
@@ -1632,7 +1632,7 @@ public void testUnionAndTimestamp() throws Exception {
assertEquals(Timestamp.valueOf("2000-03-20 12:00:00.123456789"), ts.asScratchTimestamp(0));
assertEquals(1, union.tags[0]);
assertEquals("hello", strs.toString(0));
- assertEquals(new HiveDecimalWritable(HiveDecimal.create("-5643.234")), decs.vector[0]);
+ assertEquals(new HiveDecimalWritable(HiveDecimal.create("-5643.234")), decs.get(0));
rows.close();
}
@@ -2167,8 +2167,8 @@ public void testRepeating() throws Exception {
((TimestampColumnVector) batch.cols[7]).set(0,
new Timestamp(115, 9, 23, 10, 11, 59,
999999999));
- ((DecimalColumnVector) batch.cols[8]).vector[0] =
- new HiveDecimalWritable("1.234567");
+ ((DecimalColumnVector) batch.cols[8]).set(0,
+ new HiveDecimalWritable("1.234567"));
((BytesColumnVector) batch.cols[9]).setVal(0, "Echelon".getBytes());
((BytesColumnVector) batch.cols[10]).setVal(0, "Juggernaut".getBytes());
((BytesColumnVector) batch.cols[11]).setVal(0, "Dreadnaught".getBytes());
@@ -2222,8 +2222,8 @@ public void testRepeating() throws Exception {
Timestamp ts = new Timestamp(115, 9, 25, 10, 11, 59 + r, 999999999);
((TimestampColumnVector) batch.cols[7]).set(r, ts);
- ((DecimalColumnVector) batch.cols[8]).vector[r] =
- new HiveDecimalWritable("1.234567");
+ ((DecimalColumnVector) batch.cols[8]).set(r,
+ new HiveDecimalWritable("1.234567"));
((BytesColumnVector) batch.cols[9]).setVal(r,
Integer.toString(r).getBytes());
((BytesColumnVector) batch.cols[10]).setVal(r,
@@ -2339,7 +2339,7 @@ public void testRepeating() throws Exception {
new DateWritable((int) dates.vector[r]).toString());
assertEquals("row " + r, "2015-10-23 10:11:59.999999999",
times.asScratchTimestamp(r).toString());
- assertEquals("row " + r, "1.234567", decs.vector[r].toString());
+ assertEquals("row " + r, "1.234567", decs.hiveDecimal(r).toString());
assertEquals("row " + r, "Echelon", strs.toString(r));
assertEquals("row " + r, "Juggernaut", chars.toString(r));
assertEquals("row " + r, "Dreadnaugh", vcs.toString(r));
@@ -2386,7 +2386,7 @@ public void testRepeating() throws Exception {
assertEquals("row " + r,
new Timestamp(115, 9, 25, 10, 11, 59 + r, 999999999),
times.asScratchTimestamp(r));
- assertEquals("row " + r, "1.234567", decs.vector[r].toString());
+ assertEquals("row " + r, "1.234567", decs.hiveDecimal(r).toString());
assertEquals("row " + r, Integer.toString(r), strs.toString(r));
assertEquals("row " + r, Integer.toHexString(r), chars.toString(r));
assertEquals("row " + r, Integer.toHexString(r * 128), vcs.toString(r));
diff --git orc/src/test/org/apache/orc/tools/TestFileDump.java orc/src/test/org/apache/orc/tools/TestFileDump.java
index ce3381e..2c54a88 100644
--- orc/src/test/org/apache/orc/tools/TestFileDump.java
+++ orc/src/test/org/apache/orc/tools/TestFileDump.java
@@ -148,7 +148,7 @@ static void appendAllTypes(VectorizedRowBatch batch,
((LongColumnVector) batch.cols[4]).vector[row] = l;
((DoubleColumnVector) batch.cols[5]).vector[row] = f;
((DoubleColumnVector) batch.cols[6]).vector[row] = d;
- ((DecimalColumnVector) batch.cols[7]).vector[row].set(de);
+ ((DecimalColumnVector) batch.cols[7]).set(row, de);
((TimestampColumnVector) batch.cols[8]).set(row, t);
((LongColumnVector) batch.cols[9]).vector[row] = dt.getDays();
((BytesColumnVector) batch.cols[10]).setVal(row, str.getBytes());
diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticColumnDecimal.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticColumnDecimal.txt
index e1df589..881f2d1 100644
--- ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticColumnDecimal.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticColumnDecimal.txt
@@ -61,8 +61,6 @@ public class extends VectorExpression {
DecimalColumnVector outputColVector = (DecimalColumnVector) batch.cols[outputColumn];
int[] sel = batch.selected;
int n = batch.size;
- HiveDecimalWritable[] vector1 = inputColVector1.vector;
- HiveDecimalWritable[] vector2 = inputColVector2.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -96,40 +94,15 @@ public class extends VectorExpression {
* conditional checks in the inner loop.
*/
if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
- DecimalUtil.Checked(0, vector1[0], vector2[0], outputColVector);
- } else if (inputColVector1.isRepeating) {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector1[0], vector2[i], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector1[0], vector2[i], outputColVector);
- }
- }
- } else if (inputColVector2.isRepeating) {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector1[i], vector2[0], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector1[i], vector2[0], outputColVector);
- }
- }
+ DecimalUtil.Checked(0, inputColVector1.get(0), inputColVector2.get(0), outputColVector);
} else {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector1[i], vector2[i], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector1[i], vector2[i], outputColVector);
- }
- }
+ inputColVector1.flatten(batch.selectedInUse, batch.selected, batch.size);
+ inputColVector2.flatten(batch.selectedInUse, batch.selected, batch.size);
+
+ outputColVector.(batch, inputColVector1, inputColVector2);
+
+ inputColVector1.unFlatten();
+ inputColVector2.unFlatten();
}
/* For the case when the output can have null values, follow
diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalarDecimal.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalarDecimal.txt
index 0bb1532..b384818 100644
--- ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalarDecimal.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/ColumnArithmeticScalarDecimal.txt
@@ -65,8 +65,7 @@ public class extends VectorExpression {
outputColVector.noNulls = inputColVector.noNulls;
outputColVector.isRepeating = inputColVector.isRepeating;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
-
+
// return immediately if batch is empty
if (n == 0) {
return;
@@ -89,37 +88,23 @@ public class extends VectorExpression {
}
// The following may override a "false" null setting if an error or overflow occurs.
- DecimalUtil.Checked(0, vector[0], value, outputColVector);
- } else if (inputColVector.noNulls) {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
- }
- }
- } else /* there are nulls */ {
+ DecimalUtil.Checked(0, inputColVector.get(0), value, outputColVector);
+ } else {
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
outputIsNull[i] = inputIsNull[i];
-
- // The following may override a "false" null setting if an error or overflow occurs.
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
}
} else {
System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
- for(int i = 0; i != n; i++) {
-
- // The following may override a "false" null setting if an error or overflow occurs.
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
- }
}
+
+ inputColVector.flatten(batch.selectedInUse, batch.selected, batch.size);
+ DecimalColumnVector valueVector = new DecimalColumnVector(batch.getMaxSize(), value.precision(), value.scale());
+ valueVector.fill(value, batch.getMaxSize());
+ outputColVector.(batch, inputColVector, valueVector);
+ inputColVector.unFlatten();
}
-
/*
* Null data entries are not set to a special non-zero value because all null math operations
* are checked, meaning that a zero-divide always results in a null result.
diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideColumnDecimal.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideColumnDecimal.txt
index 623bcfb..be4c95b 100644
--- ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideColumnDecimal.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideColumnDecimal.txt
@@ -61,8 +61,6 @@ public class extends VectorExpression {
DecimalColumnVector outputColVector = (DecimalColumnVector) batch.cols[outputColumn];
int[] sel = batch.selected;
int n = batch.size;
- HiveDecimalWritable[] vector1 = inputColVector1.vector;
- HiveDecimalWritable[] vector2 = inputColVector2.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -96,40 +94,15 @@ public class extends VectorExpression {
* conditional checks in the inner loop.
*/
if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
- DecimalUtil.Checked(0, vector1[0], vector2[0], outputColVector);
- } else if (inputColVector1.isRepeating) {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector1[0], vector2[i], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector1[0], vector2[i], outputColVector);
- }
- }
- } else if (inputColVector2.isRepeating) {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector1[i], vector2[0], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector1[i], vector2[0], outputColVector);
- }
- }
+ DecimalUtil.Checked(0, inputColVector1.get(0), inputColVector2.get(0), outputColVector);
} else {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, vector1[i], vector2[i], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector1[i], vector2[i], outputColVector);
- }
- }
+ inputColVector1.flatten(batch.selectedInUse, batch.selected, batch.size);
+ inputColVector2.flatten(batch.selectedInUse, batch.selected, batch.size);
+
+ outputColVector.(batch, inputColVector1, inputColVector2);
+
+ inputColVector1.unFlatten();
+ inputColVector2.unFlatten();
}
}
diff --git ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideScalarDecimal.txt ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideScalarDecimal.txt
index 841ef93..37a158f 100644
--- ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideScalarDecimal.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/ColumnDivideScalarDecimal.txt
@@ -65,8 +65,6 @@ public class extends VectorExpression {
outputColVector.noNulls = inputColVector.noNulls;
outputColVector.isRepeating = inputColVector.isRepeating;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
- HiveDecimalWritable[] outputVector = outputColVector.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -92,40 +90,26 @@ public class extends VectorExpression {
outputColVector.isRepeating = true;
outputIsNull[0] = true;
} else if (inputColVector.isRepeating) {
- DecimalUtil.Checked(0, vector[0], value, outputColVector);
+ DecimalUtil.Checked(0, inputColVector.get(0), value, outputColVector);
// Even if there are no nulls, we always copy over entry 0. Simplifies code.
outputIsNull[0] = inputIsNull[0];
- } else if (inputColVector.noNulls) {
+ } else {
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
- }
- }
- } else /* there are nulls */ {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
-
- // copy isNull entry first because operation may overwrite it
outputIsNull[i] = inputIsNull[i];
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
}
} else {
-
- // copy isNull entries first because operation may overwrite them
System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, vector[i], value, outputColVector);
- }
}
- }
+ inputColVector.flatten(batch.selectedInUse, batch.selected, batch.size);
+ DecimalColumnVector valueVector = new DecimalColumnVector(batch.getMaxSize(), value.precision(), value.scale());
+ valueVector.fill(value, batch.getMaxSize());
+ outputColVector.(batch, inputColVector, valueVector);
+ inputColVector.unFlatten();
+ }
/*
* Null data entries are not set to a special non-zero value because all null math operations
* are checked, meaning that a zero-divide always results in a null result.
diff --git ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
index 619015e..d5391fd 100644
--- ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
@@ -59,7 +59,6 @@ public class extends VectorExpression {
boolean[] outputIsNull = outputColVector.isNull;
outputColVector.noNulls = inputColVector.noNulls;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -71,7 +70,7 @@ public class extends VectorExpression {
// All must be selected otherwise size would be zero
// Repeating property will not change.
outputIsNull[0] = inputIsNull[0];
- (0, vector[0], outputColVector);
+ (0, inputColVector.get(0), outputColVector);
outputColVector.isRepeating = true;
} else if (inputColVector.noNulls) {
if (batch.selectedInUse) {
@@ -80,14 +79,14 @@ public class extends VectorExpression {
// Set isNull because decimal operation can yield a null.
outputIsNull[i] = false;
- (i, vector[i], outputColVector);
+ (i, inputColVector.get(i), outputColVector);
}
} else {
// Set isNull because decimal operation can yield a null.
Arrays.fill(outputIsNull, 0, n, false);
for(int i = 0; i != n; i++) {
- (i, vector[i], outputColVector);
+ (i, inputColVector.get(i), outputColVector);
}
}
outputColVector.isRepeating = false;
@@ -96,12 +95,12 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
outputIsNull[i] = inputIsNull[i];
- (i, vector[i], outputColVector);
+ (i, inputColVector.get(i), outputColVector);
}
} else {
System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
for(int i = 0; i != n; i++) {
- (i, vector[i], outputColVector);
+ (i, inputColVector.get(i), outputColVector);
}
}
outputColVector.isRepeating = false;
diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
index d68edfa..6786c52 100644
--- ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
@@ -62,7 +62,6 @@ public class extends VectorExpression {
int[] sel = batch.selected;
boolean[] nullPos = inputColVector.isNull;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -74,7 +73,8 @@ public class extends VectorExpression {
// All must be selected otherwise size would be zero.
// Repeating property will not change.
- if ((DecimalUtil.compare(vector[0], leftValue) < 0 || DecimalUtil.compare(vector[0], rightValue) > 0)) {
+ HiveDecimalWritable value = inputColVector.get(0);
+ if ((DecimalUtil.compare(value, leftValue) < 0 || DecimalUtil.compare(value, rightValue) > 0)) {
// Entire batch is filtered out.
batch.size = 0;
@@ -83,7 +83,8 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if ((DecimalUtil.compare(leftValue, vector[i]) <= 0 && DecimalUtil.compare(vector[i], rightValue) <= 0)) {
+ HiveDecimalWritable value = inputColVector.get(i);
+ if ((DecimalUtil.compare(leftValue, value) <= 0 && DecimalUtil.compare(value, rightValue) <= 0)) {
sel[newSize++] = i;
}
}
@@ -91,7 +92,8 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if ((DecimalUtil.compare(leftValue, vector[i]) <= 0 && DecimalUtil.compare(vector[i], rightValue) <= 0)) {
+ HiveDecimalWritable value = inputColVector.get(i);
+ if ((DecimalUtil.compare(leftValue, value) <= 0 && DecimalUtil.compare(value, rightValue) <= 0)) {
sel[newSize++] = i;
}
}
@@ -106,7 +108,8 @@ public class extends VectorExpression {
// All must be selected otherwise size would be zero.
// Repeating property will not change.
if (!nullPos[0]) {
- if ((DecimalUtil.compare(vector[0], leftValue) < 0 || DecimalUtil.compare(vector[0], rightValue) > 0)) {
+ HiveDecimalWritable value = inputColVector.get(0);
+ if ((DecimalUtil.compare(value, leftValue) < 0 || DecimalUtil.compare(value, rightValue) > 0)) {
// Entire batch is filtered out.
batch.size = 0;
@@ -119,7 +122,8 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos[i]) {
- if ((DecimalUtil.compare(leftValue, vector[i]) <= 0 && DecimalUtil.compare(vector[i], rightValue) <= 0)) {
+ HiveDecimalWritable value = inputColVector.get(i);
+ if ((DecimalUtil.compare(leftValue, value) <= 0 && DecimalUtil.compare(value, rightValue) <= 0)) {
sel[newSize++] = i;
}
}
@@ -131,7 +135,8 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos[i]) {
- if ((DecimalUtil.compare(leftValue, vector[i]) <= 0 && DecimalUtil.compare(vector[i], rightValue) <= 0)) {
+ HiveDecimalWritable value = inputColVector.get(i);
+ if ((DecimalUtil.compare(leftValue, value) <= 0 && DecimalUtil.compare(value, rightValue) <= 0)) {
sel[newSize++] = i;
}
}
diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
index a2352c6..b402768 100644
--- ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
@@ -57,8 +57,6 @@ public class extends VectorExpression {
boolean[] nullPos1 = inputColVector1.isNull;
boolean[] nullPos2 = inputColVector2.isNull;
int n = batch.size;
- HiveDecimalWritable[] vector1 = inputColVector1.vector;
- HiveDecimalWritable[] vector2 = inputColVector2.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -72,7 +70,7 @@ public class extends VectorExpression {
/* Either all must remain selected or all will be eliminated.
* Repeating property will not change.
*/
- if (!(vector1[0].compareTo(vector2[0]) 0)) {
+ if (!(inputColVector1.get(0).compareTo(inputColVector2.get(0)) 0)) {
batch.size = 0;
}
} else if (inputColVector1.isRepeating) {
@@ -80,7 +78,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -88,7 +86,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -102,7 +100,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -110,7 +108,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -123,7 +121,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -131,7 +129,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -145,7 +143,7 @@ public class extends VectorExpression {
} else if (inputColVector1.noNulls) {
if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
if (nullPos2[0] ||
- !(vector1[0].compareTo(vector2[0]) 0)) {
+ !(inputColVector1.get(0).compareTo(inputColVector2.get(0)) 0)) {
batch.size = 0;
}
} else if (inputColVector1.isRepeating) {
@@ -156,7 +154,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos2[i]) {
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -166,7 +164,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos2[i]) {
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -187,7 +185,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -195,7 +193,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -210,7 +208,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos2[i]) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -220,7 +218,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos2[i]) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -236,7 +234,7 @@ public class extends VectorExpression {
} else if (inputColVector2.noNulls) {
if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
if (nullPos1[0] ||
- !(vector1[0].compareTo(vector2[0]) 0)) {
+ !(inputColVector1.get(0).compareTo(inputColVector2.get(0)) 0)) {
batch.size = 0;
return;
}
@@ -251,7 +249,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -259,7 +257,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -274,7 +272,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos1[i]) {
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -284,7 +282,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos1[i]) {
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -300,7 +298,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos1[i]) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -310,7 +308,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos1[i]) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -326,7 +324,7 @@ public class extends VectorExpression {
} else {
if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
if (nullPos1[0] || nullPos2[0] ||
- !(vector1[0].compareTo(vector2[0]) 0)) {
+ !(inputColVector1.get(0).compareTo(inputColVector2.get(0)) 0)) {
batch.size = 0;
}
} else if (inputColVector1.isRepeating) {
@@ -339,7 +337,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos2[i]) {
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -349,7 +347,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos2[i]) {
- if (vector1[0].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(0).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -369,7 +367,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos1[i]) {
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -379,7 +377,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos1[i]) {
- if (vector1[i].compareTo(vector2[0]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(0)) 0) {
sel[newSize++] = i;
}
}
@@ -395,7 +393,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos1[i] && !nullPos2[i]) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -405,7 +403,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos1[i] && !nullPos2[i]) {
- if (vector1[i].compareTo(vector2[i]) 0) {
+ if (inputColVector1.get(i).compareTo(inputColVector2.get(i)) 0) {
sel[newSize++] = i;
}
}
diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
index bdd39b9..64788ad 100644
--- ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
@@ -54,7 +54,6 @@ public class extends VectorExpression {
int[] sel = batch.selected;
boolean[] nullPos = inputColVector.isNull;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -65,7 +64,7 @@ public class extends VectorExpression {
if (inputColVector.isRepeating) {
// All must be selected otherwise size would be zero. Repeating property will not change.
- if (!(DecimalUtil.compare(vector[0], value) 0)) {
+ if (!(DecimalUtil.compare(inputColVector.get(0), value) 0)) {
// Entire batch is filtered out.
batch.size = 0;
@@ -74,7 +73,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (DecimalUtil.compare(vector[i], value) 0) {
+ if (DecimalUtil.compare(inputColVector.get(i), value) 0) {
sel[newSize++] = i;
}
}
@@ -82,7 +81,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (DecimalUtil.compare(vector[i], value) 0) {
+ if (DecimalUtil.compare(inputColVector.get(i), value) 0) {
sel[newSize++] = i;
}
}
@@ -96,7 +95,7 @@ public class extends VectorExpression {
// All must be selected otherwise size would be zero. Repeating property will not change.
if (!nullPos[0]) {
- if (!(DecimalUtil.compare(vector[0], value) 0)) {
+ if (!(DecimalUtil.compare(inputColVector.get(0), value) 0)) {
// Entire batch is filtered out.
batch.size = 0;
@@ -109,7 +108,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos[i]) {
- if (DecimalUtil.compare(vector[i], value) 0) {
+ if (DecimalUtil.compare(inputColVector.get(i), value) 0) {
sel[newSize++] = i;
}
}
@@ -121,7 +120,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos[i]) {
- if (DecimalUtil.compare(vector[i], value) 0) {
+ if (DecimalUtil.compare(inputColVector.get(i), value) 0) {
sel[newSize++] = i;
}
}
diff --git ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
index 0608016..f6cd883 100644
--- ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
@@ -54,7 +54,6 @@ public class extends VectorExpression {
int[] sel = batch.selected;
boolean[] nullPos = inputColVector.isNull;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -65,7 +64,7 @@ public class extends VectorExpression {
if (inputColVector.isRepeating) {
// All must be selected otherwise size would be zero. Repeating property will not change.
- if (!(DecimalUtil.compare(value, vector[0]) 0)) {
+ if (!(DecimalUtil.compare(value, inputColVector.get(0)) 0)) {
// Entire batch is filtered out.
batch.size = 0;
@@ -74,7 +73,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (DecimalUtil.compare(value, vector[i]) 0) {
+ if (DecimalUtil.compare(value, inputColVector.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -82,7 +81,7 @@ public class extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (DecimalUtil.compare(value, vector[i]) 0) {
+ if (DecimalUtil.compare(value, inputColVector.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -96,7 +95,7 @@ public class extends VectorExpression {
// All must be selected otherwise size would be zero. Repeating property will not change.
if (!nullPos[0]) {
- if (!(DecimalUtil.compare(value, vector[0]) 0)) {
+ if (!(DecimalUtil.compare(value, inputColVector.get(0)) 0)) {
// Entire batch is filtered out.
batch.size = 0;
@@ -109,7 +108,7 @@ public class extends VectorExpression {
for(int j = 0; j != n; j++) {
int i = sel[j];
if (!nullPos[i]) {
- if (DecimalUtil.compare(value, vector[i]) 0) {
+ if (DecimalUtil.compare(value, inputColVector.get(i)) 0) {
sel[newSize++] = i;
}
}
@@ -121,7 +120,7 @@ public class extends VectorExpression {
int newSize = 0;
for(int i = 0; i != n; i++) {
if (!nullPos[i]) {
- if (DecimalUtil.compare(value, vector[i]) 0) {
+ if (DecimalUtil.compare(value, inputColVector.get(i)) 0) {
sel[newSize++] = i;
}
}
diff --git ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumnDecimal.txt ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumnDecimal.txt
index ea55bec..24eac76 100644
--- ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumnDecimal.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/ScalarArithmeticColumnDecimal.txt
@@ -65,8 +65,7 @@ public class extends VectorExpression {
outputColVector.noNulls = inputColVector.noNulls;
outputColVector.isRepeating = inputColVector.isRepeating;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
-
+
// return immediately if batch is empty
if (n == 0) {
return;
@@ -89,37 +88,24 @@ public class extends VectorExpression {
}
// The following may override a "false" null setting if an error or overflow occurs.
- DecimalUtil.Checked(0, value, vector[0], outputColVector);
- } else if (inputColVector.noNulls) {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
- }
- }
- } else /* there are nulls */ {
+ DecimalUtil.Checked(0, value, inputColVector.get(0), outputColVector);
+ } else {
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
outputIsNull[i] = inputIsNull[i];
-
- // The following may override a "false" null setting if an error or overflow occurs.
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
}
} else {
System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
- for(int i = 0; i != n; i++) {
-
- // The following may override a "false" null setting if an error or overflow occurs.
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
- }
}
+
+ inputColVector.flatten(batch.selectedInUse, batch.selected, batch.size);
+ DecimalColumnVector valueVector = new DecimalColumnVector(batch.getMaxSize(), value.precision(), value.scale());
+ valueVector.fill(value, batch.getMaxSize());
+ outputColVector.(batch, valueVector, inputColVector);
+ inputColVector.unFlatten();
}
-
+
NullUtil.setNullDataEntriesDecimal(outputColVector, batch.selectedInUse, sel, n);
}
diff --git ql/src/gen/vectorization/ExpressionTemplates/ScalarDivideColumnDecimal.txt ql/src/gen/vectorization/ExpressionTemplates/ScalarDivideColumnDecimal.txt
index c8a5d17..cb63b16 100644
--- ql/src/gen/vectorization/ExpressionTemplates/ScalarDivideColumnDecimal.txt
+++ ql/src/gen/vectorization/ExpressionTemplates/ScalarDivideColumnDecimal.txt
@@ -65,8 +65,6 @@ public class extends VectorExpression {
outputColVector.noNulls = inputColVector.noNulls;
outputColVector.isRepeating = inputColVector.isRepeating;
int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
- HiveDecimalWritable[] outputVector = outputColVector.vector;
// return immediately if batch is empty
if (n == 0) {
@@ -85,38 +83,25 @@ public class extends VectorExpression {
}
if (inputColVector.isRepeating) {
- DecimalUtil.Checked(0, value, vector[0], outputColVector);
+ DecimalUtil.Checked(0, value, inputColVector.get(0), outputColVector);
// Even if there are no nulls, we always copy over entry 0. Simplifies code.
outputIsNull[0] = inputIsNull[0];
- } else if (inputColVector.noNulls) {
+ } else {
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
- }
- } else {
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
- }
- }
- } else /* there are nulls */ {
- if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
-
- // copy isNull entry first because the operation may overwrite it
outputIsNull[i] = inputIsNull[i];
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
}
} else {
-
- // copy isNull entries first because the operation may overwrite them
System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
- for(int i = 0; i != n; i++) {
- DecimalUtil.Checked(i, value, vector[i], outputColVector);
- }
}
+
+ inputColVector.flatten(batch.selectedInUse, batch.selected, batch.size);
+ DecimalColumnVector valueVector = new DecimalColumnVector(batch.getMaxSize(), value.precision(), value.scale());
+ valueVector.fill(value, batch.getMaxSize());
+ outputColVector.(batch, valueVector, inputColVector);
+ inputColVector.unFlatten();
}
/*
diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt
index 9a48171..4f41ea9 100644
--- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt
+++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFMinMaxDecimal.txt
@@ -60,12 +60,12 @@ public class extends VectorAggregateExpression {
value = new HiveDecimalWritable();
}
- public void checkValue(HiveDecimalWritable writable, short scale) {
- HiveDecimal value = writable.getHiveDecimal();
+ public void checkValue(HiveDecimalWritable writable, int scale) {
+ HiveDecimalWritable value = writable;
if (isNull) {
isNull = false;
this.value.set(value);
- } else if (this.value.getHiveDecimal().compareTo(value) 0) {
+ } else if (this.value.compareTo(value) 0) {
this.value.set(value);
}
}
@@ -125,22 +125,21 @@ public class extends VectorAggregateExpression {
DecimalColumnVector inputVector = (DecimalColumnVector)batch.
cols[this.inputExpression.getOutputColumn()];
- HiveDecimalWritable[] vector = inputVector.vector;
if (inputVector.noNulls) {
if (inputVector.isRepeating) {
iterateNoNullsRepeatingWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector[0], inputVector.scale, batchSize);
+ inputVector.get(0), inputVector.scale(), batchSize);
} else {
if (batch.selectedInUse) {
iterateNoNullsSelectionWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector, inputVector.scale, batch.selected, batchSize);
+ inputVector, inputVector.scale(), batch.selected, batchSize);
} else {
iterateNoNullsWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector, inputVector.scale, batchSize);
+ inputVector, inputVector.scale(), batchSize);
}
}
} else {
@@ -148,21 +147,21 @@ public class extends VectorAggregateExpression {
if (batch.selectedInUse) {
iterateHasNullsRepeatingSelectionWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector[0], inputVector.scale, batchSize, batch.selected, inputVector.isNull);
+ inputVector.get(0), inputVector.scale(), batchSize, batch.selected, inputVector.isNull);
} else {
iterateHasNullsRepeatingWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector[0], inputVector.scale, batchSize, inputVector.isNull);
+ inputVector.get(0), inputVector.scale(), batchSize, inputVector.isNull);
}
} else {
if (batch.selectedInUse) {
iterateHasNullsSelectionWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector, inputVector.scale, batchSize, batch.selected, inputVector.isNull);
+ inputVector, inputVector.scale(), batchSize, batch.selected, inputVector.isNull);
} else {
iterateHasNullsWithAggregationSelection(
aggregationBufferSets, aggregrateIndex,
- vector, inputVector.scale, batchSize, inputVector.isNull);
+ inputVector, inputVector.scale(), batchSize, inputVector.isNull);
}
}
}
@@ -172,7 +171,7 @@ public class extends VectorAggregateExpression {
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
HiveDecimalWritable value,
- short scale,
+ int scale,
int batchSize) {
for (int i=0; i < batchSize; ++i) {
@@ -187,8 +186,8 @@ public class extends VectorAggregateExpression {
private void iterateNoNullsSelectionWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
- HiveDecimalWritable[] values,
- short scale,
+ DecimalColumnVector values,
+ int scale,
int[] selection,
int batchSize) {
@@ -197,22 +196,22 @@ public class extends VectorAggregateExpression {
aggregationBufferSets,
aggregrateIndex,
i);
- myagg.checkValue(values[selection[i]], scale);
+ myagg.checkValue(values.get(selection[i]), scale);
}
}
private void iterateNoNullsWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
- HiveDecimalWritable[] values,
- short scale,
+ DecimalColumnVector values,
+ int scale,
int batchSize) {
for (int i=0; i < batchSize; ++i) {
Aggregation myagg = getCurrentAggregationBuffer(
aggregationBufferSets,
aggregrateIndex,
i);
- myagg.checkValue(values[i], scale);
+ myagg.checkValue(values.get(i), scale);
}
}
@@ -220,7 +219,7 @@ public class extends VectorAggregateExpression {
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
HiveDecimalWritable value,
- short scale,
+ int scale,
int batchSize,
int[] selection,
boolean[] isNull) {
@@ -241,7 +240,7 @@ public class extends VectorAggregateExpression {
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
HiveDecimalWritable value,
- short scale,
+ int scale,
int batchSize,
boolean[] isNull) {
@@ -261,8 +260,8 @@ public class extends VectorAggregateExpression {
private void iterateHasNullsSelectionWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
- HiveDecimalWritable[] values,
- short scale,
+ DecimalColumnVector values,
+ int scale,
int batchSize,
int[] selection,
boolean[] isNull) {
@@ -274,7 +273,7 @@ public class extends VectorAggregateExpression {
aggregationBufferSets,
aggregrateIndex,
j);
- myagg.checkValue(values[i], scale);
+ myagg.checkValue(values.get(i), scale);
}
}
}
@@ -282,8 +281,8 @@ public class extends VectorAggregateExpression {
private void iterateHasNullsWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregrateIndex,
- HiveDecimalWritable[] values,
- short scale,
+ DecimalColumnVector values,
+ int scale,
int batchSize,
boolean[] isNull) {
@@ -293,7 +292,7 @@ public class extends VectorAggregateExpression {
aggregationBufferSets,
aggregrateIndex,
i);
- myagg.checkValue(values[i], scale);
+ myagg.checkValue(values.get(i), scale);
}
}
}
@@ -315,38 +314,36 @@ public class extends VectorAggregateExpression {
Aggregation myagg = (Aggregation)agg;
- HiveDecimalWritable[] vector = inputVector.vector;
-
if (inputVector.isRepeating) {
if (inputVector.noNulls &&
- (myagg.isNull || (myagg.value.compareTo(vector[0]) 0))) {
+ (myagg.isNull || (myagg.value.compareTo(inputVector.get(0)) 0))) {
myagg.isNull = false;
- HiveDecimal value = vector[0].getHiveDecimal();
+ HiveDecimalWritable value = inputVector.get(0);
myagg.value.set(value);
}
return;
}
if (!batch.selectedInUse && inputVector.noNulls) {
- iterateNoSelectionNoNulls(myagg, vector, inputVector.scale, batchSize);
+ iterateNoSelectionNoNulls(myagg, inputVector, inputVector.scale(), batchSize);
}
else if (!batch.selectedInUse) {
- iterateNoSelectionHasNulls(myagg, vector, inputVector.scale,
+ iterateNoSelectionHasNulls(myagg, inputVector, inputVector.scale(),
batchSize, inputVector.isNull);
}
else if (inputVector.noNulls){
- iterateSelectionNoNulls(myagg, vector, inputVector.scale, batchSize, batch.selected);
+ iterateSelectionNoNulls(myagg, inputVector, inputVector.scale(), batchSize, batch.selected);
}
else {
- iterateSelectionHasNulls(myagg, vector, inputVector.scale,
+ iterateSelectionHasNulls(myagg, inputVector, inputVector.scale(),
batchSize, inputVector.isNull, batch.selected);
}
}
private void iterateSelectionHasNulls(
Aggregation myagg,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize,
boolean[] isNull,
int[] selected) {
@@ -354,12 +351,12 @@ public class extends VectorAggregateExpression {
for (int j=0; j< batchSize; ++j) {
int i = selected[j];
if (!isNull[i]) {
- HiveDecimal value = vector[i].getHiveDecimal();
+ HiveDecimalWritable value = vector.get(i);
if (myagg.isNull) {
myagg.isNull = false;
myagg.value.set(value);
}
- else if (myagg.value.getHiveDecimal().compareTo(value) 0) {
+ else if (myagg.value.compareTo(value) 0) {
myagg.value.set(value);
}
}
@@ -368,20 +365,20 @@ public class extends VectorAggregateExpression {
private void iterateSelectionNoNulls(
Aggregation myagg,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize,
int[] selected) {
if (myagg.isNull) {
- HiveDecimal value = vector[selected[0]].getHiveDecimal();
+ HiveDecimalWritable value = vector.get(selected[0]);
myagg.value.set(value);
myagg.isNull = false;
}
for (int i=0; i< batchSize; ++i) {
- HiveDecimal value = vector[selected[i]].getHiveDecimal();
- if (myagg.value.getHiveDecimal().compareTo(value) 0) {
+ HiveDecimalWritable value = vector.get(selected[i]);
+ if (myagg.value.compareTo(value) 0) {
myagg.value.set(value);
}
}
@@ -389,19 +386,19 @@ public class extends VectorAggregateExpression {
private void iterateNoSelectionHasNulls(
Aggregation myagg,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize,
boolean[] isNull) {
for(int i=0;i 0) {
+ else if (myagg.value.compareTo(value) 0) {
myagg.value.set(value);
}
}
@@ -410,18 +407,18 @@ public class extends VectorAggregateExpression {
private void iterateNoSelectionNoNulls(
Aggregation myagg,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize) {
if (myagg.isNull) {
- HiveDecimal value = vector[0].getHiveDecimal();
+ HiveDecimalWritable value = vector.get(0);
myagg.value.set(value);
myagg.isNull = false;
}
for (int i=0;i 0) {
+ HiveDecimalWritable value = vector.get(i);
+ if (myagg.value.compareTo(value) 0) {
myagg.value.set(value);
}
}
diff --git ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt
index 8fc94ba..06ab295 100644
--- ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt
+++ ql/src/gen/vectorization/UDAFTemplates/VectorUDAFVarDecimal.txt
@@ -86,7 +86,7 @@ public class extends VectorAggregateExpression {
variance = 0f;
}
- public void updateValueWithCheckAndInit(HiveDecimalWritable value, short scale) {
+ public void updateValueWithCheckAndInit(HiveDecimalWritable value, int scale) {
if (this.isNull) {
this.init();
}
@@ -100,7 +100,7 @@ public class extends VectorAggregateExpression {
}
}
- public void updateValueNoCheck(HiveDecimalWritable value, short scale) {
+ public void updateValueNoCheck(HiveDecimalWritable value, int scale) {
double dval = value.getHiveDecimal().doubleValue();
this.sum += dval;
this.count += 1;
@@ -176,31 +176,29 @@ public class extends VectorAggregateExpression {
return;
}
- HiveDecimalWritable[] vector = inputVector.vector;
-
if (inputVector.isRepeating) {
if (inputVector.noNulls || !inputVector.isNull[0]) {
iterateRepeatingNoNullsWithAggregationSelection(
- aggregationBufferSets, aggregateIndex, vector[0], inputVector.scale, batchSize);
+ aggregationBufferSets, aggregateIndex, inputVector.get(0), inputVector.scale(), batchSize);
}
}
else if (!batch.selectedInUse && inputVector.noNulls) {
iterateNoSelectionNoNullsWithAggregationSelection(
- aggregationBufferSets, aggregateIndex, vector, inputVector.scale, batchSize);
+ aggregationBufferSets, aggregateIndex, inputVector, inputVector.scale(), batchSize);
}
else if (!batch.selectedInUse) {
iterateNoSelectionHasNullsWithAggregationSelection(
- aggregationBufferSets, aggregateIndex, vector, inputVector.scale,
+ aggregationBufferSets, aggregateIndex, inputVector, inputVector.scale(),
batchSize, inputVector.isNull);
}
else if (inputVector.noNulls){
iterateSelectionNoNullsWithAggregationSelection(
- aggregationBufferSets, aggregateIndex, vector, inputVector.scale,
+ aggregationBufferSets, aggregateIndex, inputVector, inputVector.scale(),
batchSize, batch.selected);
}
else {
iterateSelectionHasNullsWithAggregationSelection(
- aggregationBufferSets, aggregateIndex, vector, inputVector.scale, batchSize,
+ aggregationBufferSets, aggregateIndex, inputVector, inputVector.scale(), batchSize,
inputVector.isNull, batch.selected);
}
@@ -210,7 +208,7 @@ public class extends VectorAggregateExpression {
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregateIndex,
HiveDecimalWritable value,
- short scale,
+ int scale,
int batchSize) {
for (int i=0; i extends VectorAggregateExpression {
private void iterateSelectionHasNullsWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregateIndex,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize,
boolean[] isNull,
int[] selected) {
@@ -238,7 +236,7 @@ public class extends VectorAggregateExpression {
j);
int i = selected[j];
if (!isNull[i]) {
- HiveDecimalWritable value = vector[i];
+ HiveDecimalWritable value = vector.get(i);
myagg.updateValueWithCheckAndInit(value, scale);
}
}
@@ -247,8 +245,8 @@ public class extends VectorAggregateExpression {
private void iterateSelectionNoNullsWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregateIndex,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize,
int[] selected) {
@@ -257,7 +255,7 @@ public class extends VectorAggregateExpression {
aggregationBufferSets,
aggregateIndex,
i);
- HiveDecimalWritable value = vector[selected[i]];
+ HiveDecimalWritable value = vector.get(selected[i]);
myagg.updateValueWithCheckAndInit(value, scale);
}
}
@@ -265,8 +263,8 @@ public class extends VectorAggregateExpression {
private void iterateNoSelectionHasNullsWithAggregationSelection(
VectorAggregationBufferRow[] aggregationBufferSets,
int aggregateIndex,
- HiveDecimalWritable[] vector,
- short scale,
+ DecimalColumnVector vector,
+ int scale,
int batchSize,
boolean[] isNull) {
@@ -276,7 +274,7 @@ public class extends VectorAggregateExpression {
aggregationBufferSets,
aggregateIndex,
i);
- HiveDecimalWritable value = vector[i];
+ HiveDecimalWritable value = vector.get(i);
myagg.updateValueWithCheckAndInit(value, scale);
}
}
@@ -285,8 +283,8 @@ public class