You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by mm...@apache.org on 2018/02/16 15:52:45 UTC
[31/32] hive git commit: HIVE-18622: Vectorization: IF Statements,
Comparisons, and more do not handle NULLs correctly (Matt McCline,
reviewed by Sergey Shelukhin, Deepak Jaiswal, Vihang Karajgaonkar)
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticIntervalYearMonthScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticIntervalYearMonthScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticIntervalYearMonthScalar.txt
index bf4b24c..172bd39 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticIntervalYearMonthScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticIntervalYearMonthScalar.txt
@@ -18,7 +18,9 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+import java.util.Arrays;
import java.sql.Date;
+
import org.apache.hadoop.hive.common.type.HiveIntervalYearMonth;
import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector;
@@ -61,6 +63,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -74,34 +82,60 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector1.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector1.noNulls;
- outputColVector.isRepeating = inputColVector1.isRepeating;
- int n = batch.size;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
long[] vector1 = inputColVector1.vector;
long[] outputVector = outputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
+ if (inputColVector1.isRepeating) {
+ if (inputColVector1.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[0]));
+ dtm.<OperatorMethod>(
+ scratchDate1, value, outputDate);
+ outputVector[0] = DateWritable.dateToDays(outputDate);
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
+ NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n);
return;
}
- if (inputColVector1.isRepeating) {
- scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[0]));
- dtm.<OperatorMethod>(
- scratchDate1, value, outputDate);
- outputVector[0] = DateWritable.dateToDays(outputDate);
- // Even if there are no nulls, we always copy over entry 0. Simplifies code.
- outputIsNull[0] = inputIsNull[0];
- } else if (inputColVector1.noNulls) {
+ if (inputColVector1.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
- dtm.<OperatorMethod>(
- scratchDate1, value, outputDate);
- outputVector[i] = DateWritable.dateToDays(outputDate);
- }
+
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchDate1, value, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchDate1, value, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
+
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
dtm.<OperatorMethod>(
@@ -109,24 +143,39 @@ public class <ClassName> extends VectorExpression {
outputVector[i] = DateWritable.dateToDays(outputDate);
}
}
- } else /* there are nulls */ {
+ } else /* there are NULLs in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
- dtm.<OperatorMethod>(
- scratchDate1, value, outputDate);
- outputVector[i] = DateWritable.dateToDays(outputDate);
- outputIsNull[i] = inputIsNull[i];
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchDate1, value, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
} else {
for(int i = 0; i != n; i++) {
- scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
- dtm.<OperatorMethod>(
- scratchDate1, value, outputDate);
- outputVector[i] = DateWritable.dateToDays(outputDate);
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ scratchDate1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchDate1, value, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
- System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
}
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampColumn.txt
index 847ebac..a515319 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampColumn.txt
@@ -18,6 +18,7 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+import java.util.Arrays;
import java.sql.Timestamp;
import org.apache.hadoop.hive.common.type.HiveIntervalDayTime;
@@ -60,6 +61,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -74,20 +81,12 @@ public class <ClassName> extends VectorExpression {
<OutputColumnVectorType> outputColVector = (<OutputColumnVectorType>) batch.cols[outputColumnNum];
int[] sel = batch.selected;
- int n = batch.size;
- long[] vector1 = inputColVector1.vector;
- // 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];
+ long[] vector1 = inputColVector1.vector;
- // Handle nulls first
+ /*
+ * Propagate null values for a two-input operator and set isRepeating and noNulls appropriately.
+ */
NullUtil.propagateNullsColCol(
inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampScalar.txt
index 180bebc..0bae7da 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DateColumnArithmeticTimestampScalar.txt
@@ -18,6 +18,7 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+import java.util.Arrays;
import java.sql.Timestamp;
import org.apache.hadoop.hive.common.type.HiveIntervalDayTime;
@@ -61,6 +62,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -74,33 +81,58 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector1.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector1.noNulls;
- outputColVector.isRepeating = inputColVector1.isRepeating;
- int n = batch.size;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
long[] vector1 = inputColVector1.vector;
- // return immediately if batch is empty
- if (n == 0) {
+ if (inputColVector1.isRepeating) {
+ if (inputColVector1.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[0]));
+ dtm.<OperatorMethod>(
+ scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(0);
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
return;
}
- if (inputColVector1.isRepeating) {
- scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[0]));
- dtm.<OperatorMethod>(
- scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(0);
- // Even if there are no nulls, we always copy over entry 0. Simplifies code.
- outputIsNull[0] = inputIsNull[0];
- } else if (inputColVector1.noNulls) {
+ if (inputColVector1.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
- dtm.<OperatorMethod>(
- scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(i);
- }
+
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
+
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
dtm.<OperatorMethod>(
@@ -108,24 +140,39 @@ public class <ClassName> extends VectorExpression {
outputColVector.setFromScratch<CamelReturnType>(i);
}
}
- } else /* there are nulls */ {
+ } else /* there are nulls in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
- dtm.<OperatorMethod>(
- scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(i);
- outputIsNull[i] = inputIsNull[i];
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
} else {
for(int i = 0; i != n; i++) {
- scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
- dtm.<OperatorMethod>(
- scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(i);
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
+ dtm.<OperatorMethod>(
+ scratchTimestamp1, value, outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
- System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
}
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticIntervalYearMonthColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticIntervalYearMonthColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticIntervalYearMonthColumn.txt
index 4f12315..42046e0 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticIntervalYearMonthColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticIntervalYearMonthColumn.txt
@@ -19,6 +19,8 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
import java.sql.Date;
+import java.util.Arrays;
+
import org.apache.hadoop.hive.common.type.HiveIntervalYearMonth;
import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
@@ -75,6 +77,12 @@ public class <ClassName> extends VectorExpression {
*/
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -88,34 +96,59 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector2.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector2.noNulls;
- outputColVector.isRepeating = inputColVector2.isRepeating;
- int n = batch.size;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
long[] vector2 = inputColVector2.vector;
long[] outputVector = outputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
+ if (inputColVector2.isRepeating) {
+ if (inputColVector2.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ scratchIntervalYearMonth2.set((int) vector2[0]);
+ dtm.<OperatorMethod>(
+ value, scratchIntervalYearMonth2, outputDate);
+ outputVector[0] = DateWritable.dateToDays(outputDate);
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
return;
}
- if (inputColVector2.isRepeating) {
- scratchIntervalYearMonth2.set((int) vector2[0]);
- dtm.<OperatorMethod>(
- value, scratchIntervalYearMonth2, outputDate);
- outputVector[0] = DateWritable.dateToDays(outputDate);
- // Even if there are no nulls, we always copy over entry 0. Simplifies code.
- outputIsNull[0] = inputIsNull[0];
- } else if (inputColVector2.noNulls) {
+ if (inputColVector2.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- scratchIntervalYearMonth2.set((int) vector2[i]);
- dtm.<OperatorMethod>(
- value, scratchIntervalYearMonth2, outputDate);
- outputVector[i] = DateWritable.dateToDays(outputDate);
- }
+
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ scratchIntervalYearMonth2.set((int) vector2[i]);
+ dtm.<OperatorMethod>(
+ value, scratchIntervalYearMonth2, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ scratchIntervalYearMonth2.set((int) vector2[i]);
+ dtm.<OperatorMethod>(
+ value, scratchIntervalYearMonth2, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
+
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
scratchIntervalYearMonth2.set((int) vector2[i]);
dtm.<OperatorMethod>(
@@ -123,24 +156,39 @@ public class <ClassName> extends VectorExpression {
outputVector[i] = DateWritable.dateToDays(outputDate);
}
}
- } else { /* there are nulls */
+ } else /* there are NULLs in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- scratchIntervalYearMonth2.set((int) vector2[i]);
- dtm.<OperatorMethod>(
- value, scratchIntervalYearMonth2, outputDate);
- outputVector[i] = DateWritable.dateToDays(outputDate);
- outputIsNull[i] = inputIsNull[i];
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ scratchIntervalYearMonth2.set((int) vector2[i]);
+ dtm.<OperatorMethod>(
+ value, scratchIntervalYearMonth2, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
} else {
for(int i = 0; i != n; i++) {
- scratchIntervalYearMonth2.set((int) vector2[i]);
- dtm.<OperatorMethod>(
- value, scratchIntervalYearMonth2, outputDate);
- outputVector[i] = DateWritable.dateToDays(outputDate);
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ scratchIntervalYearMonth2.set((int) vector2[i]);
+ dtm.<OperatorMethod>(
+ value, scratchIntervalYearMonth2, outputDate);
+ outputVector[i] = DateWritable.dateToDays(outputDate);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
- System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
}
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticTimestampColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticTimestampColumn.txt
index a6fa2ac..191eaa6 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticTimestampColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DateScalarArithmeticTimestampColumn.txt
@@ -19,6 +19,7 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
import java.sql.Timestamp;
+import java.util.Arrays;
import org.apache.hadoop.hive.common.type.HiveIntervalDayTime;
import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
@@ -75,6 +76,12 @@ public class <ClassName> extends VectorExpression {
*/
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -88,52 +95,91 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector2.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector2.noNulls;
- outputColVector.isRepeating = inputColVector2.isRepeating;
- int n = batch.size;
- // return immediately if batch is empty
- if (n == 0) {
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
+ if (inputColVector2.isRepeating) {
+ if (inputColVector2.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ dtm.<OperatorMethod>(
+ value, inputColVector2.asScratch<CamelOperandType2>(0), outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(0);
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
+ NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n);
return;
}
- if (inputColVector2.isRepeating) {
- dtm.<OperatorMethod>(
- value, inputColVector2.asScratch<CamelOperandType2>(0), outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(0);
- // Even if there are no nulls, we always copy over entry 0. Simplifies code.
- outputIsNull[0] = inputIsNull[0];
- } else if (inputColVector2.noNulls) {
+ if (inputColVector2.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- dtm.<OperatorMethod>(
- value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(i);
- }
+
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ dtm.<OperatorMethod>(
+ value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ dtm.<OperatorMethod>(
+ value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
+
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
dtm.<OperatorMethod>(
value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
outputColVector.setFromScratch<CamelReturnType>(i);
}
}
- } else { /* there are nulls */
+ } else /* there are NULLs in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- dtm.<OperatorMethod>(
- value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(i);
- outputIsNull[i] = inputIsNull[i];
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ dtm.<OperatorMethod>(
+ value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
} else {
for(int i = 0; i != n; i++) {
- dtm.<OperatorMethod>(
- value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
- outputColVector.setFromScratch<CamelReturnType>(i);
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ dtm.<OperatorMethod>(
+ value, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
+ outputColVector.setFromScratch<CamelReturnType>(i);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
- System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
}
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Column.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Column.txt b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Column.txt
index 30b03ba..5b643bb 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Column.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Column.txt
@@ -54,6 +54,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -62,39 +68,18 @@ public class <ClassName> extends VectorExpression {
Decimal64ColumnVector inputColVector2 = (Decimal64ColumnVector) batch.cols[colNum2];
Decimal64ColumnVector outputColVector = (Decimal64ColumnVector) batch.cols[outputColumnNum];
int[] sel = batch.selected;
- int n = batch.size;
+
long[] vector1 = inputColVector1.vector;
long[] vector2 = inputColVector2.vector;
long[] outputVector = outputColVector.vector;
boolean[] outputIsNull = outputColVector.isNull;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
final long outputDecimal64AbsMax =
HiveDecimalWritable.getDecimal64AbsMax(outputColVector.precision);
- 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
+ /*
+ * Propagate null values for a two-input operator and set isRepeating and noNulls appropriately.
+ */
NullUtil.propagateNullsColCol(
inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Scalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Scalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Scalar.txt
index 81dcf33..fa091d4 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Scalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnArithmeticDecimal64Scalar.txt
@@ -18,10 +18,11 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+import java.util.Arrays;
+
import org.apache.hadoop.hive.ql.exec.vector.Decimal64ColumnVector;
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.NullUtil;
import org.apache.hadoop.hive.ql.exec.vector.expressions.Decimal64Util;
import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
@@ -55,6 +56,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -64,55 +71,71 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector.noNulls;
- outputColVector.isRepeating = inputColVector.isRepeating;
- int n = batch.size;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
long[] vector = inputColVector.vector;
long[] outputVector = outputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
final long outputDecimal64AbsMax =
HiveDecimalWritable.getDecimal64AbsMax(outputColVector.precision);
- if (inputColVector.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, inputColVector.isRepeating,
- batch.selectedInUse, sel, n);
- }
if (inputColVector.isRepeating) {
- if (!inputColVector.noNulls) {
- outputIsNull[0] = inputIsNull[0];
- }
- // The following may override a "false" null setting if an error or overflow occurs.
- final long result = vector[0] <OperatorSymbol> value;
- outputVector[0] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
+ if (inputColVector.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ final long result = vector[0] <OperatorSymbol> value;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ } else {
+ outputVector[0] = result;
+ }
+ } else {
outputIsNull[0] = true;
+ outputColVector.noNulls = false;
}
- } else if (inputColVector.noNulls) {
+ outputColVector.isRepeating = true;
+ return;
+ }
+
+ if (inputColVector.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- final long result = vector[i] <OperatorSymbol> value;
- outputVector[i] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
- outputIsNull[i] = true;
+
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ final long result = vector[i] <OperatorSymbol> value;
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputColVector.noNulls = false;
+ outputIsNull[i] = true;
+ }
}
- }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ final long result = vector[i] <OperatorSymbol> value;
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputColVector.noNulls = false;
+ outputIsNull[i] = true;
+ }
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
+
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
final long result = vector[i] <OperatorSymbol> value;
outputVector[i] = result;
@@ -122,37 +145,48 @@ public class <ClassName> extends VectorExpression {
}
}
}
- } else /* there are nulls */ {
+ } else /* there are NULLs in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
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.
- final long result = vector[i] <OperatorSymbol> value;
- outputVector[i] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ final long result = vector[i] <OperatorSymbol> value;
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ } else {
outputIsNull[i] = true;
+ outputColVector.noNulls = false;
}
}
} 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.
- final long result = vector[i] <OperatorSymbol> value;
- outputVector[i] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ final long result = vector[i] <OperatorSymbol> value;
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ } else {
outputIsNull[i] = true;
+ outputColVector.noNulls = false;
}
}
}
}
-
- // Currently, we defer division, etc to regular HiveDecimal so we don't do any null
- // default value setting here.
}
@Override
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarArithmeticDecimal64Column.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarArithmeticDecimal64Column.txt b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarArithmeticDecimal64Column.txt
index dc6ccb9..db813b7 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarArithmeticDecimal64Column.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarArithmeticDecimal64Column.txt
@@ -18,10 +18,11 @@
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+import java.util.Arrays;
+
import org.apache.hadoop.hive.ql.exec.vector.Decimal64ColumnVector;
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.NullUtil;
import org.apache.hadoop.hive.ql.exec.vector.expressions.Decimal64Util;
import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
@@ -56,6 +57,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -65,95 +72,120 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector.noNulls;
- outputColVector.isRepeating = inputColVector.isRepeating;
- int n = batch.size;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
long[] vector = inputColVector.vector;
long[] outputVector = outputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
final long outputDecimal64AbsMax =
HiveDecimalWritable.getDecimal64AbsMax(outputColVector.precision);
- if (inputColVector.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, inputColVector.isRepeating,
- batch.selectedInUse, sel, n);
- }
-
if (inputColVector.isRepeating) {
- if (!inputColVector.noNulls) {
- outputIsNull[0] = inputIsNull[0];
- }
-
- // The following may override a "false" null setting if an error or overflow occurs.
- final long result = value <OperatorSymbol> vector[0];
- outputVector[0] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
+ if (inputColVector.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ final long result = value <OperatorSymbol> vector[0];
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ } else {
+ outputVector[0] = result;
+ }
+ } else {
outputIsNull[0] = true;
+ outputColVector.noNulls = false;
}
- } else if (inputColVector.noNulls) {
+ outputColVector.isRepeating = true;
+ return;
+ }
+
+ if (inputColVector.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- final long result = value <OperatorSymbol> vector[i];
- outputVector[i] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
- outputIsNull[i] = true;
+
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ final long result = value <OperatorSymbol> vector[i];
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
- }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ final long result = value <OperatorSymbol> vector[i];
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
+
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
final long result = value <OperatorSymbol> vector[i];
outputVector[i] = result;
if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
outputIsNull[i] = true;
+ outputColVector.noNulls = false;
}
}
}
- } else /* there are nulls */ {
+ } else /* there are NULLs in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
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.
- final long result = value <OperatorSymbol> vector[i];
- outputVector[i] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ final long result = value <OperatorSymbol> vector[i];
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ } else {
outputIsNull[i] = true;
+ outputColVector.noNulls = false;
}
}
} 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.
- final long result = value <OperatorSymbol> vector[i];
- outputVector[i] = result;
- if (Math.abs(result) > outputDecimal64AbsMax) {
- outputColVector.noNulls = false;
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ final long result = value <OperatorSymbol> vector[i];
+ outputVector[i] = result;
+ if (Math.abs(result) > outputDecimal64AbsMax) {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ } else {
outputIsNull[i] = true;
+ outputColVector.noNulls = false;
}
}
}
}
-
- // Currently, we defer division, etc to regular HiveDecimal so we don't do any null
- // default value setting here.
}
@Override
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt b/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
index 1ab5228..5e684b4 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnUnaryFunc.txt
@@ -15,9 +15,11 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-
+
package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+import java.util.Arrays;
+
import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
import org.apache.hadoop.hive.ql.exec.vector.expressions.MathExpr;
import org.apache.hadoop.hive.ql.exec.vector.*;
@@ -27,7 +29,6 @@ import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
import org.apache.hadoop.hive.ql.exec.vector.DecimalColumnVector;
import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector;
import org.apache.hadoop.hive.ql.exec.vector.expressions.DecimalUtil;
-import java.util.Arrays;
public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
@@ -49,6 +50,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
this.evaluateChildren(batch);
}
@@ -58,54 +65,86 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] inputIsNull = inputColVector.isNull;
boolean[] outputIsNull = outputColVector.isNull;
- outputColVector.noNulls = inputColVector.noNulls;
- int n = batch.size;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
HiveDecimalWritable[] vector = inputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
+ if (inputColVector.isRepeating) {
+ if (inputColVector.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ <FuncName>(0, vector[0], outputColVector);
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
return;
}
- if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero
- // Repeating property will not change.
- outputIsNull[0] = inputIsNull[0];
- <FuncName>(0, vector[0], outputColVector);
- outputColVector.isRepeating = true;
- } else if (inputColVector.noNulls) {
+ if (inputColVector.noNulls) {
if (batch.selectedInUse) {
- for(int j = 0; j != n; j++) {
- int i = sel[j];
- // Set isNull because decimal operation can yield a null.
- outputIsNull[i] = false;
- <FuncName>(i, vector[i], outputColVector);
- }
+ // CONSIDER: For large n, fill n or all of isNull array and use the tighter ELSE loop.
+
+ if (!outputColVector.noNulls) {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ <FuncName>(i, vector[i], outputColVector);
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ // The following may override a "false" null setting if an error or overflow occurs.
+ <FuncName>(i, vector[i], outputColVector);
+ }
+ }
} else {
+ if (!outputColVector.noNulls) {
- // Set isNull because decimal operation can yield a null.
- Arrays.fill(outputIsNull, 0, n, false);
+ // Assume it is almost always a performance win to fill all of isNull so we can
+ // safely reset noNulls.
+ Arrays.fill(outputIsNull, false);
+ outputColVector.noNulls = true;
+ }
for(int i = 0; i != n; i++) {
+ // The following may override a "false" null setting if an error or overflow occurs.
<FuncName>(i, vector[i], outputColVector);
}
}
- outputColVector.isRepeating = false;
- } else /* there are nulls */ {
+ } else /* there are nulls in the inputColVector */ {
+
+ /*
+ * Do careful maintenance of the outputColVector.noNulls flag.
+ */
+
if (batch.selectedInUse) {
for(int j = 0; j != n; j++) {
int i = sel[j];
- outputIsNull[i] = inputIsNull[i];
- <FuncName>(i, vector[i], outputColVector);
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ <FuncName>(i, vector[i], outputColVector);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
} else {
- System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
for(int i = 0; i != n; i++) {
- <FuncName>(i, vector[i], outputColVector);
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ // The following may override a "false" null setting if an error or overflow occurs.
+ <FuncName>(i, vector[i], outputColVector);
+ } else {
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
}
}
- outputColVector.isRepeating = false;
}
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnBetween.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnBetween.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnBetween.txt
index 36ad892..55eb50e 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnBetween.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnBetween.txt
@@ -57,28 +57,27 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
<InputColumnVectorType> inputColVector = (<InputColumnVectorType>) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
+ boolean[] inputIsNull = inputColVector.isNull;
+
<OperandType>[] vector = inputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero.
- // Repeating property will not change.
+
if (<OptionalNot>(vector[0] < leftValue || vector[0] > rightValue)) {
-
+
// Entire batch is filtered out.
batch.size = 0;
}
@@ -105,12 +104,9 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero.
- // Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (<OptionalNot>(vector[0] < leftValue || vector[0] > rightValue)) {
-
+
// Entire batch is filtered out.
batch.size = 0;
}
@@ -121,7 +117,7 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (<OptionalNot>(leftValue <= vector[i] && vector[i] <= rightValue)) {
sel[newSize++] = i;
}
@@ -132,7 +128,7 @@ public class <ClassName> extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (<OptionalNot>(leftValue <= vector[i] && vector[i] <= rightValue)) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt
index 150d341..e458992 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareColumn.txt
@@ -53,6 +53,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -62,15 +68,10 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] nullPos1 = inputColVector1.isNull;
boolean[] nullPos2 = inputColVector2.isNull;
- int n = batch.size;
+
<OperandType1>[] vector1 = inputColVector1.vector;
<OperandType2>[] vector2 = inputColVector2.vector;
-
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
+
// filter rows with NULL on left input
int newSize;
newSize = NullUtil.filterNulls(batch.cols[colNum1], batch.selectedInUse, sel, n);
@@ -85,12 +86,9 @@ public class <ClassName> extends VectorExpression {
n = batch.size = newSize;
batch.selectedInUse = true;
}
-
+
// All rows with nulls have been filtered out, so just do normal filter for non-null case
if (n != 0 && inputColVector1.isRepeating && inputColVector2.isRepeating) {
-
- // All must be selected otherwise size would be zero
- // Repeating property will not change.
if (!(vector1[0] <OperatorSymbol> vector2[0])) {
batch.size = 0;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt
index a9ddeca..c955c06 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterColumnCompareScalar.txt
@@ -51,25 +51,24 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
<InputColumnVectorType> inputColVector = (<InputColumnVectorType>) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
+ boolean[] inputIsNull = inputColVector.isNull;
+
<OperandType1>[] vector = inputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
- //All must be selected otherwise size would be zero
- //Repeating property will not change.
if (!(vector[0] <OperatorSymbol> value)) {
//Entire batch is filtered out.
batch.size = 0;
@@ -97,9 +96,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
- //All must be selected otherwise size would be zero
- //Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (!(vector[0] <OperatorSymbol> value)) {
//Entire batch is filtered out.
batch.size = 0;
@@ -111,7 +108,7 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j=0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (vector[i] <OperatorSymbol> value) {
sel[newSize++] = i;
}
@@ -122,7 +119,7 @@ public class <ClassName> extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (vector[i] <OperatorSymbol> value) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
index 7c41f3e..f42668c 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnBetween.txt
@@ -60,26 +60,24 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
DecimalColumnVector inputColVector = (DecimalColumnVector) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
+ boolean[] inputIsNull = inputColVector.isNull;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
+ HiveDecimalWritable[] vector = inputColVector.vector;
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero.
- // Repeating property will not change.
if (<OptionalNot>(DecimalUtil.compare(vector[0], leftValue) < 0 || DecimalUtil.compare(vector[0], rightValue) > 0)) {
// Entire batch is filtered out.
@@ -108,10 +106,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero.
- // Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (<OptionalNot>(DecimalUtil.compare(vector[0], leftValue) < 0 || DecimalUtil.compare(vector[0], rightValue) > 0)) {
// Entire batch is filtered out.
@@ -124,19 +119,19 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (<OptionalNot>(DecimalUtil.compare(leftValue, vector[i]) <= 0 && DecimalUtil.compare(vector[i], rightValue) <= 0)) {
sel[newSize++] = i;
}
}
}
-
+
// Change the selected vector
batch.size = newSize;
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (<OptionalNot>(DecimalUtil.compare(leftValue, vector[i]) <= 0 && DecimalUtil.compare(vector[i], rightValue) <= 0)) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
index 6a82183..77fe7ae 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalColumn.txt
@@ -53,6 +53,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -62,15 +68,10 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
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) {
- return;
- }
-
// handle case where neither input has nulls
if (inputColVector1.noNulls && inputColVector2.noNulls) {
if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
index 80a19d9..078b132 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalColumnCompareDecimalScalar.txt
@@ -53,24 +53,24 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
DecimalColumnVector inputColVector = (DecimalColumnVector) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
+ boolean[] inputIsNull = inputColVector.isNull;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
+ HiveDecimalWritable[] vector = inputColVector.vector;
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero. Repeating property will not change.
if (!(DecimalUtil.compare(vector[0], value) <OperatorSymbol> 0)) {
// Entire batch is filtered out.
@@ -99,9 +99,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero. Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (!(DecimalUtil.compare(vector[0], value) <OperatorSymbol> 0)) {
// Entire batch is filtered out.
@@ -114,7 +112,7 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (DecimalUtil.compare(vector[i], value) <OperatorSymbol> 0) {
sel[newSize++] = i;
}
@@ -126,7 +124,7 @@ public class <ClassName> extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (DecimalUtil.compare(vector[i], value) <OperatorSymbol> 0) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
index 4b7e849..20dbaba 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterDecimalScalarCompareDecimalColumn.txt
@@ -53,24 +53,24 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
DecimalColumnVector inputColVector = (DecimalColumnVector) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
- HiveDecimalWritable[] vector = inputColVector.vector;
+ boolean[] inputIsNull = inputColVector.isNull;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
+ HiveDecimalWritable[] vector = inputColVector.vector;
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero. Repeating property will not change.
if (!(DecimalUtil.compare(value, vector[0]) <OperatorSymbol> 0)) {
// Entire batch is filtered out.
@@ -99,9 +99,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero. Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (!(DecimalUtil.compare(value, vector[0]) <OperatorSymbol> 0)) {
// Entire batch is filtered out.
@@ -114,7 +112,7 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j = 0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (DecimalUtil.compare(value, vector[i]) <OperatorSymbol> 0) {
sel[newSize++] = i;
}
@@ -126,7 +124,7 @@ public class <ClassName> extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (DecimalUtil.compare(value, vector[i]) <OperatorSymbol> 0) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleColumnCompareTimestampColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleColumnCompareTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleColumnCompareTimestampColumn.txt
index f741409..4afed54 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleColumnCompareTimestampColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleColumnCompareTimestampColumn.txt
@@ -56,6 +56,12 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
@@ -65,13 +71,8 @@ public class <ClassName> extends VectorExpression {
int[] sel = batch.selected;
boolean[] nullPos1 = inputColVector1.isNull;
boolean[] nullPos2 = inputColVector2.isNull;
- int n = batch.size;
- <OperandType>[] vector1 = inputColVector1.vector;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
+ <OperandType>[] vector1 = inputColVector1.vector;
// filter rows with NULL on left input
int newSize;
@@ -90,9 +91,6 @@ public class <ClassName> extends VectorExpression {
// All rows with nulls have been filtered out, so just do normal filter for non-null case
if (n != 0 && inputColVector1.isRepeating && inputColVector2.isRepeating) {
-
- // All must be selected otherwise size would be zero
- // Repeating property will not change.
if (!(vector1[0] <OperatorSymbol> inputColVector2.<GetTimestampLongDoubleMethod>(0))) {
batch.size = 0;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleScalarCompareTimestampColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleScalarCompareTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleScalarCompareTimestampColumn.txt
index 8ece14f..8f8104d 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleScalarCompareTimestampColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterLongDoubleScalarCompareTimestampColumn.txt
@@ -57,24 +57,22 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
TimestampColumnVector inputColVector = (TimestampColumnVector) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
-
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
+ boolean[] inputIsNull = inputColVector.isNull;
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
- //All must be selected otherwise size would be zero
- //Repeating property will not change.
if (!(value <OperatorSymbol> inputColVector.<GetTimestampLongDoubleMethod>(0))) {
//Entire batch is filtered out.
batch.size = 0;
@@ -102,9 +100,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
- //All must be selected otherwise size would be zero
- //Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (!(value <OperatorSymbol> inputColVector.<GetTimestampLongDoubleMethod>(0))) {
//Entire batch is filtered out.
batch.size = 0;
@@ -116,7 +112,7 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j=0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (value <OperatorSymbol> inputColVector.<GetTimestampLongDoubleMethod>(i)) {
sel[newSize++] = i;
}
@@ -127,7 +123,7 @@ public class <ClassName> extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (value <OperatorSymbol> inputColVector.<GetTimestampLongDoubleMethod>(i)) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt
index 18840f1..28b5704 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterScalarCompareColumn.txt
@@ -52,25 +52,24 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
<InputColumnVectorType> inputColVector = (<InputColumnVectorType>) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
+ boolean[] inputIsNull = inputColVector.isNull;
+
<OperandType2>[] vector = inputColVector.vector;
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
- //All must be selected otherwise size would be zero
- //Repeating property will not change.
if (!(value <OperatorSymbol> vector[0])) {
//Entire batch is filtered out.
batch.size = 0;
@@ -98,9 +97,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
- //All must be selected otherwise size would be zero
- //Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (!(value <OperatorSymbol> vector[0])) {
//Entire batch is filtered out.
batch.size = 0;
@@ -112,7 +109,7 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j=0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (value <OperatorSymbol> vector[i]) {
sel[newSize++] = i;
}
@@ -123,7 +120,7 @@ public class <ClassName> extends VectorExpression {
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (value <OperatorSymbol> vector[i]) {
sel[newSize++] = i;
}
http://git-wip-us.apache.org/repos/asf/hive/blob/a4689020/ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnBetween.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnBetween.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnBetween.txt
index b9a332a..b7f70e1 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnBetween.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterStringColumnBetween.txt
@@ -56,27 +56,26 @@ public class <ClassName> extends VectorExpression {
@Override
public void evaluate(VectorizedRowBatch batch) {
+
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
if (childExpressions != null) {
super.evaluateChildren(batch);
}
BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum];
int[] sel = batch.selected;
- boolean[] nullPos = inputColVector.isNull;
- int n = batch.size;
+ boolean[] inputIsNull = inputColVector.isNull;
+
byte[][] vector = inputColVector.vector;
int[] length = inputColVector.length;
int[] start = inputColVector.start;
-
- // return immediately if batch is empty
- if (n == 0) {
- return;
- }
-
if (inputColVector.noNulls) {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero. Repeating property will not change.
if (<OptionalNot>(StringExpr.compare(vector[0], start[0], length[0], left, 0, left.length) < 0
|| StringExpr.compare(right, 0, right.length, vector[0], start[0], length[0]) < 0)) {
@@ -108,9 +107,7 @@ public class <ClassName> extends VectorExpression {
}
} else {
if (inputColVector.isRepeating) {
-
- // All must be selected otherwise size would be zero. Repeating property will not change.
- if (!nullPos[0]) {
+ if (!inputIsNull[0]) {
if (<OptionalNot>(StringExpr.compare(vector[0], start[0], length[0], left, 0, left.length) < 0
|| StringExpr.compare(right, 0, right.length, vector[0], start[0], length[0]) < 0)) {
@@ -124,20 +121,20 @@ public class <ClassName> extends VectorExpression {
int newSize = 0;
for(int j=0; j != n; j++) {
int i = sel[j];
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (<OptionalNot>(StringExpr.compare(left, 0, left.length, vector[i], start[i], length[i]) <= 0
&& StringExpr.compare(vector[i], start[i], length[i], right, 0, right.length) <= 0)) {
sel[newSize++] = i;
}
}
}
-
+
//Change the selected vector
batch.size = newSize;
} else {
int newSize = 0;
for(int i = 0; i != n; i++) {
- if (!nullPos[i]) {
+ if (!inputIsNull[i]) {
if (<OptionalNot>(StringExpr.compare(left, 0, left.length, vector[i], start[i], length[i]) <= 0
&& StringExpr.compare(vector[i], start[i], length[i], right, 0, right.length) <= 0)) {
sel[newSize++] = i;