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/07/25 15:06:04 UTC
[8/8] hive git commit: HIVE-20207: Vectorization: Fix NULL / Wrong
Results issues in Filter / Compare (Matt McCline, reviewed by Teddy Choi)
HIVE-20207: Vectorization: Fix NULL / Wrong Results issues in Filter / Compare (Matt McCline, reviewed by Teddy Choi)
Project: http://git-wip-us.apache.org/repos/asf/hive/repo
Commit: http://git-wip-us.apache.org/repos/asf/hive/commit/71c49878
Tree: http://git-wip-us.apache.org/repos/asf/hive/tree/71c49878
Diff: http://git-wip-us.apache.org/repos/asf/hive/diff/71c49878
Branch: refs/heads/master
Commit: 71c49878c3669f19f900ec1ffe7652c91ce15d38
Parents: ca0d706
Author: Matt McCline <mm...@hortonworks.com>
Authored: Wed Jul 25 09:58:51 2018 -0500
Committer: Matt McCline <mm...@hortonworks.com>
Committed: Wed Jul 25 09:59:35 2018 -0500
----------------------------------------------------------------------
.../VectorizedComparisonBench.java | 19 +-
.../ExpressionTemplates/ColumnCompareColumn.txt | 4 +-
.../ExpressionTemplates/ColumnCompareScalar.txt | 4 +-
.../Decimal64ColumnCompareDecimal64Column.txt | 54 +
.../Decimal64ColumnCompareDecimal64Scalar.txt | 66 +
.../Decimal64ScalarCompareDecimal64Column.txt | 66 +
.../DecimalColumnCompareDecimalColumn.txt | 153 +
.../DecimalColumnCompareDecimalScalar.txt | 177 +
.../DecimalScalarCompareDecimalColumn.txt | 180 +
.../ExpressionTemplates/IfExprColumnScalar.txt | 6 +-
.../IfExprObjectColumnColumn.txt | 41 +
.../IfExprObjectColumnScalar.txt | 22 +
.../IfExprObjectScalarColumn.txt | 22 +
.../ExpressionTemplates/IfExprScalarColumn.txt | 6 +-
.../ExpressionTemplates/IfExprScalarScalar.txt | 6 +-
.../ExpressionTemplates/ScalarCompareColumn.txt | 4 +-
.../exec/vector/VectorExpressionDescriptor.java | 2 +
.../ql/exec/vector/VectorizationContext.java | 222 +-
.../exec/vector/VectorizationContext.java.orig | 3771 ++++++++++++++++++
.../vector/expressions/CastCharToBinary.java | 55 +
.../expressions/CastStringToTimestamp.java | 177 +
.../IfExprCharScalarStringScalar.java | 2 +-
.../IfExprDecimal64ColumnDecimal64Column.java | 55 +
.../IfExprDecimal64ColumnDecimal64Scalar.java | 70 +
.../IfExprDecimal64ScalarDecimal64Column.java | 71 +
.../IfExprDecimal64ScalarDecimal64Scalar.java | 75 +
.../expressions/IfExprLongColumnLongColumn.java | 6 +-
...fExprStringGroupColumnStringGroupColumn.java | 4 +-
.../IfExprStringGroupColumnStringScalar.java | 4 +-
.../IfExprStringScalarStringGroupColumn.java | 4 +-
.../IfExprStringScalarStringScalar.java | 4 +-
.../IfExprVarCharScalarStringScalar.java | 2 +-
.../expressions/LongColEqualLongColumn.java | 146 -
.../expressions/LongColEqualLongScalar.java | 157 -
.../LongColGreaterEqualLongColumn.java | 146 -
.../LongColGreaterEqualLongScalar.java | 158 -
.../expressions/LongColGreaterLongColumn.java | 146 -
.../expressions/LongColGreaterLongScalar.java | 157 -
.../expressions/LongColLessEqualLongColumn.java | 146 -
.../expressions/LongColLessEqualLongScalar.java | 158 -
.../expressions/LongColLessLongColumn.java | 146 -
.../expressions/LongColLessLongScalar.java | 158 -
.../expressions/LongColNotEqualLongColumn.java | 146 -
.../expressions/LongColNotEqualLongScalar.java | 158 -
.../expressions/LongScalarEqualLongColumn.java | 157 -
.../LongScalarGreaterEqualLongColumn.java | 160 -
.../LongScalarGreaterLongColumn.java | 161 -
.../LongScalarLessEqualLongColumn.java | 160 -
.../expressions/LongScalarLessLongColumn.java | 161 -
.../LongScalarNotEqualLongColumn.java | 161 -
.../hive/ql/udf/generic/GenericUDFIf.java | 16 +
.../hive/ql/udf/generic/GenericUDFOPEqual.java | 8 +-
.../generic/GenericUDFOPEqualOrGreaterThan.java | 8 +-
.../generic/GenericUDFOPEqualOrLessThan.java | 8 +-
.../ql/udf/generic/GenericUDFOPGreaterThan.java | 8 +-
.../ql/udf/generic/GenericUDFOPLessThan.java | 8 +-
.../ql/udf/generic/GenericUDFOPNotEqual.java | 8 +-
.../ql/udf/generic/GenericUDFTimestamp.java | 3 +-
.../exec/vector/TestVectorizationContext.java | 4 +-
.../expressions/TestVectorArithmetic.java | 11 +
.../expressions/TestVectorCastStatement.java | 42 +-
.../expressions/TestVectorDateAddSub.java | 10 +
.../vector/expressions/TestVectorDateDiff.java | 11 +
.../expressions/TestVectorFilterCompare.java | 795 ++++
.../expressions/TestVectorIfStatement.java | 74 +-
.../vector/expressions/TestVectorNegative.java | 9 +
.../expressions/TestVectorStringConcat.java | 11 +
.../expressions/TestVectorStringUnary.java | 12 +-
.../vector/expressions/TestVectorSubStr.java | 9 +
.../expressions/TestVectorTimestampExtract.java | 9 +
.../convert_decimal64_to_decimal.q.out | 6 +-
.../llap/convert_decimal64_to_decimal.q.out | 10 +-
.../llap/vector_case_when_1.q.out | 12 +-
.../llap/vector_decimal_mapjoin.q.out | 24 +-
.../llap/vector_outer_reference_windowed.q.out | 48 +-
.../llap/vector_udf_adaptor_1.q.out | 32 +-
.../clientpositive/llap/vectorized_case.q.out | 16 +-
.../clientpositive/llap/vectorized_casts.q.out | 4 +-
...vectorized_dynamic_semijoin_reduction2.q.out | 4 +-
.../llap/vectorized_mapjoin3.q.out | 6 +-
.../llap/vectorized_timestamp_funcs.q.out | 12 +-
.../llap/vectorized_timestamp_ints_casts.q.out | 8 +-
.../spark/vector_decimal_mapjoin.q.out | 24 +-
.../clientpositive/spark/vectorized_case.q.out | 16 +-
.../spark/vectorized_timestamp_funcs.q.out | 12 +-
.../clientpositive/vector_case_when_1.q.out | 12 +-
.../clientpositive/vector_decimal_mapjoin.q.out | 16 +-
.../clientpositive/vectorized_case.q.out | 16 +-
.../clientpositive/vectorized_casts.q.out | 4 +-
.../vectorized_timestamp_funcs.q.out | 12 +-
.../vectorized_timestamp_ints_casts.q.out | 8 +-
.../ql/exec/vector/DecimalColumnVector.java | 21 +-
.../ql/exec/vector/expressions/StringExpr.java | 17 +
.../apache/hadoop/hive/tools/GenVectorCode.java | 126 +-
94 files changed, 6520 insertions(+), 3146 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedComparisonBench.java
----------------------------------------------------------------------
diff --git a/itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedComparisonBench.java b/itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedComparisonBench.java
index 4c616f6..d54d1fa 100644
--- a/itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedComparisonBench.java
+++ b/itests/hive-jmh/src/main/java/org/apache/hive/benchmark/vectorization/VectorizedComparisonBench.java
@@ -14,24 +14,7 @@
package org.apache.hive.benchmark.vectorization;
import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColEqualLongScalar;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColGreaterEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColGreaterEqualLongScalar;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColGreaterLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColGreaterLongScalar;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColLessEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColLessEqualLongScalar;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColLessLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColLessLongScalar;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColNotEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongColNotEqualLongScalar;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalarEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalarGreaterEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalarGreaterLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalarLessEqualLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalarLessLongColumn;
-import org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalarNotEqualLongColumn;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.gen.*;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.runner.Runner;
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareColumn.txt
index 56d96b8..84b2869 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareColumn.txt
@@ -33,8 +33,8 @@ public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
- private final int colNum1;
- private final int colNum2;
+ protected final int colNum1;
+ protected final int colNum2;
public <ClassName>(int colNum1, int colNum2, int outputColumnNum) {
super(outputColumnNum);
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt
index 9556066..640feb3 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/ColumnCompareScalar.txt
@@ -36,8 +36,8 @@ public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
- private final int colNum;
- private final <OperandType2> value;
+ protected final int colNum;
+ protected final <OperandType2> value;
public <ClassName>(int colNum, <OperandType2> value, int outputColumnNum) {
super(outputColumnNum);
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Column.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Column.txt b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Column.txt
new file mode 100644
index 0000000..d260716
--- /dev/null
+++ b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Column.txt
@@ -0,0 +1,54 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+
+/**
+ * Generated from template Decimal64ColumnCompareDecimal64Column.txt, which covers
+ * decimal64 comparison expressions between two columns, however output is not produced in
+ * a separate column. The selected vector of the input {@link VectorizedRowBatch} is updated
+ * for in-place filtering.
+ */
+public class <ClassName> extends <BaseClassName> {
+
+ private static final long serialVersionUID = 1L;
+
+ public <ClassName>(int colNum1, int colNum2, int outputColumnNum) {
+ super(colNum1, colNum2, outputColumnNum);
+ }
+
+ public <ClassName>() {
+ super();
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.DECIMAL_64,
+ VectorExpressionDescriptor.ArgumentType.DECIMAL_64)
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Scalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Scalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Scalar.txt
new file mode 100644
index 0000000..802b9a6
--- /dev/null
+++ b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ColumnCompareDecimal64Scalar.txt
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo;
+
+/**
+ * Generated from template Decimal64ColumnCompareDecimal64Scalar.txt, which covers decimal64
+ * comparison expressions between a column and a scalar, however output is not produced in a
+ * separate column. The selected vector of the input {@link VectorizedRowBatch} is updated for
+ * in-place filtering.
+ */
+public class <ClassName> extends <BaseClassName> {
+
+ private static final long serialVersionUID = 1L;
+
+ public <ClassName>(int colNum, long value, int outputColumnNum) {
+ super(colNum, value, outputColumnNum);
+ }
+
+ public <ClassName>() {
+ super();
+ }
+
+ @Override
+ public String vectorExpressionParameters() {
+ DecimalTypeInfo decimalTypeInfo = (DecimalTypeInfo) inputTypeInfos[0];
+ HiveDecimalWritable writable = new HiveDecimalWritable();
+ writable.deserialize64(value, decimalTypeInfo.scale());
+ return getColumnParamString(0, colNum) + ", decimal64Val " + value +
+ ", decimalVal " + writable.toString();
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.DECIMAL_64,
+ VectorExpressionDescriptor.ArgumentType.DECIMAL_64)
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.SCALAR).build();
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarCompareDecimal64Column.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarCompareDecimal64Column.txt b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarCompareDecimal64Column.txt
new file mode 100644
index 0000000..c8b10b6
--- /dev/null
+++ b/ql/src/gen/vectorization/ExpressionTemplates/Decimal64ScalarCompareDecimal64Column.txt
@@ -0,0 +1,66 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.hadoop.hive.serde2.typeinfo.DecimalTypeInfo;
+
+/**
+ * Generated from template Decimal64ScalarCompareDecimal64Column.txt, which covers decimal64
+ * comparison expressions between a scalar and a column, however output is not produced in a
+ * separate column. The selected vector of the input {@link VectorizedRowBatch} is updated for
+ * in-place filtering.
+ */
+public class <ClassName> extends <BaseClassName> {
+
+ private static final long serialVersionUID = 1L;
+
+ public <ClassName>(long value, int colNum, int outputColumnNum) {
+ super(value, colNum, outputColumnNum);
+ }
+
+ public <ClassName>() {
+ super();
+ }
+
+ @Override
+ public String vectorExpressionParameters() {
+ DecimalTypeInfo decimalTypeInfo = (DecimalTypeInfo) inputTypeInfos[1];
+ HiveDecimalWritable writable = new HiveDecimalWritable();
+ writable.deserialize64(value, decimalTypeInfo.scale());
+ return "decimal64Val " + value + ", decimalVal " + writable.toString() +
+ ", " + getColumnParamString(1, colNum);
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.DECIMAL_64,
+ VectorExpressionDescriptor.ArgumentType.DECIMAL_64)
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.SCALAR,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalColumn.txt
new file mode 100644
index 0000000..1a68de9
--- /dev/null
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalColumn.txt
@@ -0,0 +1,153 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.*;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.metadata.HiveException;
+
+/**
+ * Generated from template DecimalColumnCompareDecimalColumn.txt, which covers comparision
+ * expressions between Decimal columns.
+ */
+public class <ClassName> extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private final int colNum1;
+ private final int colNum2;
+
+ public <ClassName>(int colNum1, int colNum2, int outputColumnNum) {
+ super(outputColumnNum);
+ this.colNum1 = colNum1;
+ this.colNum2 = colNum2;
+ }
+
+ public <ClassName>() {
+ super();
+
+ // Dummy final assignments.
+ colNum1 = -1;
+ colNum2 = -1;
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) throws HiveException {
+
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector1 = (DecimalColumnVector) batch.cols[colNum1];
+ HiveDecimalWritable[] vector1 = inputColVector1.vector;
+
+ DecimalColumnVector inputColVector2 = (DecimalColumnVector) batch.cols[colNum2];
+ HiveDecimalWritable[] vector2 = inputColVector2.vector;
+
+ LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumnNum];
+ int[] sel = batch.selected;
+ long[] outputVector = outputColVector.vector;
+
+ /*
+ * Propagate null values for a two-input operator and set isRepeating and noNulls appropriately.
+ */
+ 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) {
+ outputVector[0] = vector1[0].compareTo(vector2[0]) <OperatorSymbol> 0 ? 1 : 0;
+ } else if (inputColVector1.isRepeating) {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ outputVector[i] = vector1[0].compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ outputVector[i] = vector1[0].compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ } else if (inputColVector2.isRepeating) {
+ HiveDecimalWritable value2 = vector2[0];
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ outputVector[i] = vector1[i].compareTo(value2) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ outputVector[i] = vector1[i].compareTo(value2) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ } else {
+ if (batch.selectedInUse) {
+ for(int j = 0; j != n; j++) {
+ int i = sel[j];
+ outputVector[i] = vector1[i].compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ outputVector[i] = vector1[i].compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ }
+
+ /* For the case when the output can have null values, follow
+ * the convention that the data values must be 1 for long and
+ * NaN for double. 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.setNullDataEntriesLong(outputColVector, batch.selectedInUse, sel, n);
+ }
+
+ @Override
+ public String vectorExpressionParameters() {
+ return getColumnParamString(0, colNum1) + ", " + getColumnParamString(1, colNum2);
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.DECIMAL,
+ VectorExpressionDescriptor.ArgumentType.DECIMAL)
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalScalar.txt
new file mode 100644
index 0000000..8d09137
--- /dev/null
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DecimalColumnCompareDecimalScalar.txt
@@ -0,0 +1,177 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import java.util.Arrays;
+
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.hadoop.hive.common.type.HiveDecimal;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.*;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.metadata.HiveException;
+
+/**
+ * Generated from template DecimalColumnCompareDecimalScalar.txt, which covers binary comparison
+ * expressions between a column and a scalar. The boolean output is stored in a
+ * separate boolean column.
+ */
+public class <ClassName> extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private final int colNum;
+ private final HiveDecimalWritable value;
+
+ public <ClassName>(int colNum, HiveDecimal value, int outputColumnNum) {
+ super(outputColumnNum);
+ this.colNum = colNum;
+ this.value = new HiveDecimalWritable(value);
+ }
+
+ public <ClassName>() {
+ super();
+
+ // Dummy final assignments.
+ colNum = -1;
+ value = null;
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) throws HiveException {
+
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector1 = (DecimalColumnVector) batch.cols[colNum];
+ HiveDecimalWritable[] vector1 = inputColVector1.vector;
+
+ LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumnNum];
+
+ int[] sel = batch.selected;
+ boolean[] inputIsNull = inputColVector1.isNull;
+ boolean[] outputIsNull = outputColVector.isNull;
+ long[] outputVector = outputColVector.vector;
+
+ // We do not need to do a column reset since we are carefully changing the output.
+ outputColVector.isRepeating = false;
+
+ if (inputColVector1.isRepeating) {
+ if (inputColVector1.noNulls || !inputIsNull[0]) {
+ outputIsNull[0] = false;
+ outputVector[0] = vector1[0].compareTo(value) <OperatorSymbol> 0 ? 1 : 0;
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
+ NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n);
+ return;
+ }
+
+ if (inputColVector1.noNulls) {
+ if (batch.selectedInUse) {
+
+ // 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;
+ outputVector[i] = vector1[i].compareTo(value) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputVector[i] = vector1[i].compareTo(value) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ } 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++) {
+ outputVector[i] = vector1[i].compareTo(value) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ } 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];
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ outputVector[i] = vector1[i].compareTo(value) <OperatorSymbol> 0 ? 1 : 0;
+ } else {
+ // Comparison with NULL is NULL.
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ }
+ } else {
+ for(int i = 0; i != n; i++) {
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ outputVector[i] = vector1[i].compareTo(value) <OperatorSymbol> 0 ? 1 : 0;
+ } else {
+ // Comparison with NULL is NULL.
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public String vectorExpressionParameters() {
+ return getColumnParamString(0, colNum) + ", val " + value.toString();
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.DECIMAL,
+ VectorExpressionDescriptor.ArgumentType.DECIMAL)
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.COLUMN,
+ VectorExpressionDescriptor.InputExpressionType.SCALAR).build();
+ }
+}
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/DecimalScalarCompareDecimalColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/DecimalScalarCompareDecimalColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/DecimalScalarCompareDecimalColumn.txt
new file mode 100644
index 0000000..1275260
--- /dev/null
+++ b/ql/src/gen/vectorization/ExpressionTemplates/DecimalScalarCompareDecimalColumn.txt
@@ -0,0 +1,180 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
+
+import java.util.Arrays;
+
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+import org.apache.hadoop.hive.common.type.HiveDecimal;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
+import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
+import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector;
+import org.apache.hadoop.hive.ql.exec.vector.*;
+import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
+import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
+import org.apache.hadoop.hive.ql.metadata.HiveException;
+
+/**
+ * Generated from template DecimalScalarCompareDecimalColumn.txt, which covers comparison
+ * expressions between a long/double scalar and a column. The boolean output is stored in a
+ * separate boolean column.
+ */
+public class <ClassName> extends VectorExpression {
+
+ private static final long serialVersionUID = 1L;
+
+ private final HiveDecimalWritable value;
+ private final int colNum;
+
+ public <ClassName>(HiveDecimal value, int colNum, int outputColumnNum) {
+ super(outputColumnNum);
+ this.value = new HiveDecimalWritable(value);
+ this.colNum = colNum;
+ }
+
+ public <ClassName>() {
+ super();
+
+ // Dummy final assignments.
+ value = null;
+ colNum = -1;
+ }
+
+ @Override
+ public void evaluate(VectorizedRowBatch batch) throws HiveException {
+
+ // return immediately if batch is empty
+ final int n = batch.size;
+ if (n == 0) {
+ return;
+ }
+
+ if (childExpressions != null) {
+ super.evaluateChildren(batch);
+ }
+
+ DecimalColumnVector inputColVector2 = (DecimalColumnVector) batch.cols[colNum];
+ HiveDecimalWritable[] vector2 = inputColVector2.vector;
+
+ LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumnNum];
+
+ int[] sel = batch.selected;
+ boolean[] inputIsNull = inputColVector2.isNull;
+ boolean[] outputIsNull = outputColVector.isNull;
+
+ long[] outputVector = outputColVector.vector;
+
+ // 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;
+ outputVector[0] = value.compareTo(vector2[0]) <OperatorSymbol> 0 ? 1 : 0;
+ } else {
+ outputIsNull[0] = true;
+ outputColVector.noNulls = false;
+ }
+ outputColVector.isRepeating = true;
+ NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n);
+ return;
+ }
+
+ if (inputColVector2.noNulls) {
+ if (batch.selectedInUse) {
+
+ // 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;
+ outputVector[i] = value.compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ } else {
+ for(int j = 0; j != n; j++) {
+ final int i = sel[j];
+ outputVector[i] = value.compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ } 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++) {
+ outputVector[i] = value.compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ }
+ }
+ } 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];
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ outputVector[i] = value.compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ } else {
+ // Comparison with NULL is NULL.
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ }
+ } else {
+ System.arraycopy(inputIsNull, 0, outputIsNull, 0, n);
+ for(int i = 0; i != n; i++) {
+ if (!inputIsNull[i]) {
+ outputIsNull[i] = false;
+ outputVector[i] = value.compareTo(vector2[i]) <OperatorSymbol> 0 ? 1 : 0;
+ } else {
+ // Comparison with NULL is NULL.
+ outputIsNull[i] = true;
+ outputColVector.noNulls = false;
+ }
+ }
+ }
+ }
+ }
+
+ @Override
+ public String vectorExpressionParameters() {
+ return "val " + value.toString() + ", " + getColumnParamString(1, colNum);
+ }
+
+ @Override
+ public VectorExpressionDescriptor.Descriptor getDescriptor() {
+ return (new VectorExpressionDescriptor.Builder())
+ .setMode(
+ VectorExpressionDescriptor.Mode.PROJECTION)
+ .setNumArguments(2)
+ .setArgumentTypes(
+ VectorExpressionDescriptor.ArgumentType.DECIMAL,
+ VectorExpressionDescriptor.ArgumentType.DECIMAL)
+ .setInputExpressionTypes(
+ VectorExpressionDescriptor.InputExpressionType.SCALAR,
+ VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
+ }
+}
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/IfExprColumnScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IfExprColumnScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/IfExprColumnScalar.txt
index d50a6f6..3eec95e 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/IfExprColumnScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/IfExprColumnScalar.txt
@@ -35,9 +35,9 @@ public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
- private final int arg1Column;
- private final int arg2Column;
- private final <OperandType3> arg3Scalar;
+ protected final int arg1Column;
+ protected final int arg2Column;
+ protected final <OperandType3> arg3Scalar;
public <ClassName>(int arg1Column, int arg2Column, <OperandType3> arg3Scalar,
int outputColumnNum) {
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnColumn.txt
index e8ef279..a8ca31b 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnColumn.txt
@@ -23,6 +23,9 @@ import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
import org.apache.hadoop.hive.ql.metadata.HiveException;
+#IF DECIMAL
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+#ENDIF DECIMAL
/**
* Compute IF(expr1, expr2, expr3) for 3 input column expressions.
@@ -64,8 +67,14 @@ public class <ClassName> extends VectorExpression {
LongColumnVector arg1ColVector = (LongColumnVector) batch.cols[arg1Column];
<ColumnVectorType> arg2ColVector = (<ColumnVectorType>) batch.cols[arg2Column];
boolean[] arg2IsNull = arg2ColVector.isNull;
+#IF DECIMAL
+ HiveDecimalWritable[] vector2 = arg2ColVector.vector;
+#ENDIF DECIMAL
<ColumnVectorType> arg3ColVector = (<ColumnVectorType>) batch.cols[arg3Column];
boolean[] arg3IsNull = arg3ColVector.isNull;
+#IF DECIMAL
+ HiveDecimalWritable[] vector3 = arg3ColVector.vector;
+#ENDIF DECIMAL
<ColumnVectorType> outputColVector = (<ColumnVectorType>) batch.cols[outputColumnNum];
int[] sel = batch.selected;
boolean[] outputIsNull = outputColVector.isNull;
@@ -107,7 +116,11 @@ public class <ClassName> extends VectorExpression {
if (vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -115,7 +128,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -127,7 +144,11 @@ public class <ClassName> extends VectorExpression {
if (vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -135,7 +156,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -150,7 +175,11 @@ public class <ClassName> extends VectorExpression {
if (!arg1ColVector.isNull[i] && vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -158,7 +187,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -170,7 +203,11 @@ public class <ClassName> extends VectorExpression {
if (!arg1ColVector.isNull[i] && vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -178,7 +215,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnScalar.txt
index 56ae2ca..f0d2908 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectColumnScalar.txt
@@ -25,6 +25,9 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
import <ScalarImport>;
import org.apache.hadoop.hive.ql.metadata.HiveException;
+#IF DECIMAL
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+#ENDIF DECIMAL
/**
* Compute IF(expr1, expr2, expr3) for 3 input column expressions.
@@ -67,6 +70,9 @@ public class <ClassName> extends VectorExpression {
LongColumnVector arg1ColVector = (LongColumnVector) batch.cols[arg1Column];
<ColumnVectorType> arg2ColVector = (<ColumnVectorType>) batch.cols[arg2Column];
boolean[] arg2IsNull = arg2ColVector.isNull;
+#IF DECIMAL
+ HiveDecimalWritable[] vector2 = arg2ColVector.vector;
+#ENDIF DECIMAL
<ColumnVectorType> outputColVector = (<ColumnVectorType>) batch.cols[outputColumnNum];
int[] sel = batch.selected;
boolean[] outputIsNull = outputColVector.isNull;
@@ -104,7 +110,11 @@ public class <ClassName> extends VectorExpression {
if (vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -119,7 +129,11 @@ public class <ClassName> extends VectorExpression {
if (vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -138,7 +152,11 @@ public class <ClassName> extends VectorExpression {
if (!arg1ColVector.isNull[i] && vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -153,7 +171,11 @@ public class <ClassName> extends VectorExpression {
if (!arg1ColVector.isNull[i] && vector1[i] == 1) {
if (!arg2IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector2[i]);
+#ELSE
outputColVector.set(i, arg2ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectScalarColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectScalarColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectScalarColumn.txt
index 271b589..980f506 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectScalarColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/IfExprObjectScalarColumn.txt
@@ -25,6 +25,9 @@ import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
import <ScalarImport>;
import org.apache.hadoop.hive.ql.metadata.HiveException;
+#IF DECIMAL
+import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable;
+#ENDIF DECIMAL
/**
* Compute IF(expr1, expr2, expr3) for 3 input column expressions.
@@ -67,6 +70,9 @@ public class <ClassName> extends VectorExpression {
LongColumnVector arg1ColVector = (LongColumnVector) batch.cols[arg1Column];
<ColumnVectorType> arg3ColVector = (<ColumnVectorType>) batch.cols[arg3Column];
boolean[] arg3IsNull = arg3ColVector.isNull;
+#IF DECIMAL
+ HiveDecimalWritable[] vector3 = arg3ColVector.vector;
+#ENDIF DECIMAL
<ColumnVectorType> outputColVector = (<ColumnVectorType>) batch.cols[outputColumnNum];
int[] sel = batch.selected;
boolean[] outputIsNull = outputColVector.isNull;
@@ -109,7 +115,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -124,7 +134,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -143,7 +157,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
@@ -158,7 +176,11 @@ public class <ClassName> extends VectorExpression {
} else {
if (!arg3IsNull[i]) {
outputIsNull[i] = false;
+#IF DECIMAL
+ outputColVector.set(i, vector3[i]);
+#ELSE
outputColVector.set(i, arg3ColVector.asScratch<ObjectName>(i));
+#ENDIF DECIMAL
} else {
outputIsNull[i] = true;
outputColVector.noNulls = false;
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarColumn.txt
index 3658129..a5a2957 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarColumn.txt
@@ -35,9 +35,9 @@ public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
- private final int arg1Column;
- private final <OperandType2> arg2Scalar;
- private final int arg3Column;
+ protected final int arg1Column;
+ protected final <OperandType2> arg2Scalar;
+ protected final int arg3Column;
public <ClassName>(int arg1Column, <OperandType2> arg2Scalar, int arg3Column,
int outputColumnNum) {
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarScalar.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarScalar.txt
index d11459a..20ce883 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarScalar.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/IfExprScalarScalar.txt
@@ -36,9 +36,9 @@ public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
- private final int arg1Column;
- private final <OperandType2> arg2Scalar;
- private final <OperandType3> arg3Scalar;
+ protected final int arg1Column;
+ protected final <OperandType2> arg2Scalar;
+ protected final <OperandType3> arg3Scalar;
public <ClassName>(int arg1Column, <OperandType2> arg2Scalar, <OperandType3> arg3Scalar,
int outputColumnNum) {
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/gen/vectorization/ExpressionTemplates/ScalarCompareColumn.txt
----------------------------------------------------------------------
diff --git a/ql/src/gen/vectorization/ExpressionTemplates/ScalarCompareColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/ScalarCompareColumn.txt
index 753f061..60dc725 100644
--- a/ql/src/gen/vectorization/ExpressionTemplates/ScalarCompareColumn.txt
+++ b/ql/src/gen/vectorization/ExpressionTemplates/ScalarCompareColumn.txt
@@ -37,8 +37,8 @@ public class <ClassName> extends VectorExpression {
private static final long serialVersionUID = 1L;
- private final <OperandType1> value;
- private final int colNum;
+ protected final <OperandType1> value;
+ protected final int colNum;
public <ClassName>(<OperandType1> value, int colNum, int outputColumnNum) {
super(outputColumnNum);
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorExpressionDescriptor.java
----------------------------------------------------------------------
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorExpressionDescriptor.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorExpressionDescriptor.java
index 2f8a419..fb40f5e 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorExpressionDescriptor.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorExpressionDescriptor.java
@@ -89,6 +89,8 @@ public class VectorExpressionDescriptor {
INT_INTERVAL_YEAR_MONTH (INT_FAMILY.value | INTERVAL_YEAR_MONTH.value),
INT_DATE_INTERVAL_YEAR_MONTH (INT_FAMILY.value | DATE.value | INTERVAL_YEAR_MONTH.value),
STRING_DATETIME_FAMILY (STRING_FAMILY.value | DATETIME_FAMILY.value),
+ STRING_FAMILY_BINARY (STRING_FAMILY.value | BINARY.value),
+ STRING_BINARY (STRING.value | BINARY.value),
ALL_FAMILY (0xFFFFFFL);
private final long value;
http://git-wip-us.apache.org/repos/asf/hive/blob/71c49878/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java
----------------------------------------------------------------------
diff --git a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java
index 20cc894..e541217 100644
--- a/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java
+++ b/ql/src/java/org/apache/hadoop/hive/ql/exec/vector/VectorizationContext.java
@@ -1533,88 +1533,88 @@ public class VectorizationContext {
return false;
}
- public boolean haveCandidateForDecimal64VectorExpression(int numChildren,
- List<ExprNodeDesc> childExpr, TypeInfo returnType) throws HiveException {
-
- // For now, just 2 Decimal64 inputs and a Decimal64 or boolean output.
- return (numChildren == 2 &&
- checkExprNodeDescForDecimal64(childExpr.get(0)) &&
- checkExprNodeDescForDecimal64(childExpr.get(1)) &&
- (checkTypeInfoForDecimal64(returnType) ||
- returnType.equals(TypeInfoFactory.booleanTypeInfo)));
- }
-
private VectorExpression getDecimal64VectorExpressionForUdf(GenericUDF genericUdf,
- Class<?> udfClass, List<ExprNodeDesc> childExpr, int numChildren,
- VectorExpressionDescriptor.Mode mode, TypeInfo returnType) throws HiveException {
-
- ExprNodeDesc child1 = childExpr.get(0);
- ExprNodeDesc child2 = childExpr.get(1);
-
- DecimalTypeInfo decimalTypeInfo1 = (DecimalTypeInfo) child1.getTypeInfo();
- DecimalTypeInfo decimalTypeInfo2 = (DecimalTypeInfo) child2.getTypeInfo();
-
- DataTypePhysicalVariation dataTypePhysicalVariation1 = DataTypePhysicalVariation.DECIMAL_64;
- DataTypePhysicalVariation dataTypePhysicalVariation2 = DataTypePhysicalVariation.DECIMAL_64;
-
- final int scale1 = decimalTypeInfo1.scale();
- final int scale2 = decimalTypeInfo2.scale();
+ Class<?> udfClass, List<ExprNodeDesc> childExprs, int numChildren,
+ VectorExpressionDescriptor.Mode mode, TypeInfo returnTypeInfo) throws HiveException {
VectorExpressionDescriptor.Builder builder = new VectorExpressionDescriptor.Builder();
builder.setNumArguments(numChildren);
builder.setMode(mode);
- boolean isColumnScaleEstablished = false;
- int columnScale = 0;
- boolean hasScalar = false;
- builder.setArgumentType(0, ArgumentType.DECIMAL_64);
- if (child1 instanceof ExprNodeGenericFuncDesc ||
- child1 instanceof ExprNodeColumnDesc) {
- builder.setInputExpressionType(0, InputExpressionType.COLUMN);
- isColumnScaleEstablished = true;
- columnScale = scale1;
- } else if (child1 instanceof ExprNodeConstantDesc) {
- if (isNullConst(child1)) {
-
- // Cannot handle NULL scalar parameter.
+ // DECIMAL_64 decimals must have same scale.
+ boolean anyDecimal64Expr = false;
+ boolean isDecimal64ScaleEstablished = false;
+ int decimal64ColumnScale = 0;
+
+ for (int i = 0; i < numChildren; i++) {
+ ExprNodeDesc childExpr = childExprs.get(i);
+
+ /*
+ * For columns, we check decimal columns for DECIMAL_64 DataTypePhysicalVariation.
+ * For UDFs, we check for @VectorizedExpressionsSupportDecimal64 annotation, etc.
+ */
+ final boolean isExprDecimal64 = checkExprNodeDescForDecimal64(childExpr);
+ if (isExprDecimal64) {
+ anyDecimal64Expr = true;
+ }
+
+ TypeInfo typeInfo = childExpr.getTypeInfo();
+ if (childExpr instanceof ExprNodeGenericFuncDesc ||
+ childExpr instanceof ExprNodeColumnDesc) {
+ if (isExprDecimal64) {
+ DecimalTypeInfo decimalTypeInfo = (DecimalTypeInfo) typeInfo;
+ if (!isDecimal64ScaleEstablished) {
+ decimal64ColumnScale = decimalTypeInfo.getScale();
+ isDecimal64ScaleEstablished = true;
+ } else if (decimalTypeInfo.getScale() != decimal64ColumnScale) {
+ return null;
+ }
+ }
+ builder.setInputExpressionType(i, InputExpressionType.COLUMN);
+ } else if (childExpr instanceof ExprNodeConstantDesc) {
+ if (isNullConst(childExpr)) {
+ // Cannot handle NULL scalar parameter.
+ return null;
+ }
+ builder.setInputExpressionType(i, InputExpressionType.SCALAR);
+ } else {
return null;
}
- hasScalar = true;
- builder.setInputExpressionType(0, InputExpressionType.SCALAR);
- } else {
- // Currently, only functions, columns, and scalars supported.
- return null;
+ if (isExprDecimal64) {
+ builder.setArgumentType(i, ArgumentType.DECIMAL_64);
+ } else {
+ String undecoratedTypeName = getUndecoratedName(childExpr.getTypeString());
+ if (undecoratedTypeName == null) {
+ return null;
+ }
+ builder.setArgumentType(i, undecoratedTypeName);
+ }
}
- builder.setArgumentType(1, ArgumentType.DECIMAL_64);
- if (child2 instanceof ExprNodeGenericFuncDesc ||
- child2 instanceof ExprNodeColumnDesc) {
- builder.setInputExpressionType(1, InputExpressionType.COLUMN);
- if (!isColumnScaleEstablished) {
- isColumnScaleEstablished = true;
- columnScale = scale2;
- } else if (columnScale != scale2) {
-
- // We only support Decimal64 on 2 columns when the have the same scale.
- return null;
- }
- } else if (child2 instanceof ExprNodeConstantDesc) {
- // Cannot have SCALAR, SCALAR.
- if (!isColumnScaleEstablished) {
- return null;
- }
- if (isNullConst(child2)) {
+ if (!anyDecimal64Expr) {
+ return null;
+ }
- // Cannot handle NULL scalar parameter.
+ final boolean isReturnDecimal64 = checkTypeInfoForDecimal64(returnTypeInfo);
+ final DataTypePhysicalVariation returnDataTypePhysicalVariation;
+ if (isReturnDecimal64) {
+ DecimalTypeInfo returnDecimalTypeInfo = (DecimalTypeInfo) returnTypeInfo;
+ if (!isDecimal64ScaleEstablished) {
+ decimal64ColumnScale = returnDecimalTypeInfo.getScale();
+ isDecimal64ScaleEstablished = true;
+ } else if (returnDecimalTypeInfo.getScale() != decimal64ColumnScale) {
return null;
}
- hasScalar = true;
- builder.setInputExpressionType(1, InputExpressionType.SCALAR);
- } else {
+ returnDataTypePhysicalVariation = DataTypePhysicalVariation.DECIMAL_64;
+ } else if (returnTypeInfo instanceof DecimalTypeInfo){
- // Currently, only functions, columns, and scalars supported.
+ // Currently, we don't have any vectorized expressions that take DECIMAL_64 inputs
+ // and produce a regular decimal. Or, currently, a way to express that in the
+ // descriptor.
return null;
+ } else {
+ returnDataTypePhysicalVariation = DataTypePhysicalVariation.NONE;
}
VectorExpressionDescriptor.Descriptor descriptor = builder.build();
@@ -1632,19 +1632,26 @@ public class VectorizationContext {
List<VectorExpression> children = new ArrayList<VectorExpression>();
Object[] arguments = new Object[numChildren];
+ TypeInfo[] typeInfos = new TypeInfo[numChildren];
+ DataTypePhysicalVariation[] dataTypePhysicalVariations = new DataTypePhysicalVariation[numChildren];
for (int i = 0; i < numChildren; i++) {
- ExprNodeDesc child = childExpr.get(i);
- if (child instanceof ExprNodeGenericFuncDesc) {
- VectorExpression vChild = getVectorExpression(child, childrenMode);
+ ExprNodeDesc childExpr = childExprs.get(i);
+ TypeInfo typeInfo = childExpr.getTypeInfo();
+ typeInfos[i] = typeInfo;
+ dataTypePhysicalVariations[i] =
+ (checkTypeInfoForDecimal64(typeInfo) ?
+ DataTypePhysicalVariation.DECIMAL_64 : DataTypePhysicalVariation.NONE);
+ if (childExpr instanceof ExprNodeGenericFuncDesc) {
+ VectorExpression vChild = getVectorExpression(childExpr, childrenMode);
children.add(vChild);
arguments[i] = vChild.getOutputColumnNum();
- } else if (child instanceof ExprNodeColumnDesc) {
- int colIndex = getInputColumnIndex((ExprNodeColumnDesc) child);
+ } else if (childExpr instanceof ExprNodeColumnDesc) {
+ int colIndex = getInputColumnIndex((ExprNodeColumnDesc) childExpr);
if (childrenMode == VectorExpressionDescriptor.Mode.FILTER) {
VectorExpression filterExpr =
- getFilterOnBooleanColumnExpression((ExprNodeColumnDesc) child, colIndex);
+ getFilterOnBooleanColumnExpression((ExprNodeColumnDesc) childExpr, colIndex);
if (filterExpr == null) {
return null;
}
@@ -1653,16 +1660,27 @@ public class VectorizationContext {
}
arguments[i] = colIndex;
} else {
- Preconditions.checkState(child instanceof ExprNodeConstantDesc);
- ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) child;
- HiveDecimal hiveDecimal = (HiveDecimal) constDesc.getValue();
- if (hiveDecimal.scale() > columnScale) {
+ Preconditions.checkState(childExpr instanceof ExprNodeConstantDesc);
+ ExprNodeConstantDesc constDesc = (ExprNodeConstantDesc) childExpr;
+ if (typeInfo instanceof DecimalTypeInfo) {
+ if (!isDecimal64ScaleEstablished) {
+ return null;
+ }
+ HiveDecimal hiveDecimal = (HiveDecimal) constDesc.getValue();
+ if (hiveDecimal.scale() > decimal64ColumnScale) {
- // For now, bail out on decimal constants with larger scale than column scale.
- return null;
+ // For now, bail out on decimal constants with larger scale than column scale.
+ return null;
+ }
+ final long decimal64Scalar =
+ new HiveDecimalWritable(hiveDecimal).serialize64(decimal64ColumnScale);
+ arguments[i] = decimal64Scalar;
+ } else {
+ Object scalarValue = getVectorTypeScalarValue(constDesc);
+ arguments[i] =
+ (scalarValue == null) ?
+ getConstantVectorExpression(null, typeInfo, childrenMode) : scalarValue;
}
- final long decimal64Scalar = new HiveDecimalWritable(hiveDecimal).serialize64(columnScale);
- arguments[i] = decimal64Scalar;
}
}
@@ -1672,13 +1690,13 @@ public class VectorizationContext {
* The instantiateExpression method sets the output column and type information.
*/
VectorExpression vectorExpression =
- instantiateExpression(vectorClass, returnType, DataTypePhysicalVariation.DECIMAL_64, arguments);
+ instantiateExpression(vectorClass, returnTypeInfo, returnDataTypePhysicalVariation, arguments);
if (vectorExpression == null) {
- handleCouldNotInstantiateVectorExpression(vectorClass, returnType, DataTypePhysicalVariation.DECIMAL_64, arguments);
+ handleCouldNotInstantiateVectorExpression(vectorClass, returnTypeInfo, returnDataTypePhysicalVariation, arguments);
}
- vectorExpression.setInputTypeInfos(decimalTypeInfo1, decimalTypeInfo2);
- vectorExpression.setInputDataTypePhysicalVariations(dataTypePhysicalVariation1, dataTypePhysicalVariation2);
+ vectorExpression.setInputTypeInfos(typeInfos);
+ vectorExpression.setInputDataTypePhysicalVariations(dataTypePhysicalVariations);
if ((vectorExpression != null) && !children.isEmpty()) {
vectorExpression.setChildExpressions(children.toArray(new VectorExpression[0]));
@@ -1728,16 +1746,15 @@ public class VectorizationContext {
return null;
}
- // Should we intercept here for a possible Decimal64 vector expression class?
- if (haveCandidateForDecimal64VectorExpression(numChildren, childExpr, returnType)) {
- VectorExpression result = getDecimal64VectorExpressionForUdf(genericUdf, udfClass,
- childExpr, numChildren, mode, returnType);
- if (result != null) {
- return result;
- }
- // Otherwise, fall through and proceed with non-Decimal64 vector expression classes...
+ // Intercept here for a possible Decimal64 vector expression class.
+ VectorExpression result = getDecimal64VectorExpressionForUdf(genericUdf, udfClass,
+ childExpr, numChildren, mode, returnType);
+ if (result != null) {
+ return result;
}
+ // Otherwise, fall through and proceed with non-Decimal64 vector expression classes...
+
VectorExpressionDescriptor.Builder builder = new VectorExpressionDescriptor.Builder();
builder.setNumArguments(numChildren);
builder.setMode(mode);
@@ -2062,6 +2079,8 @@ public class VectorizationContext {
ve = getCastToChar(childExpr, returnType);
} else if (udf instanceof GenericUDFToVarchar) {
ve = getCastToVarChar(childExpr, returnType);
+ } else if (udf instanceof GenericUDFToBinary) {
+ ve = getCastToBinary(childExpr, returnType);
} else if (udf instanceof GenericUDFTimestamp) {
ve = getCastToTimestamp((GenericUDFTimestamp)udf, childExpr, mode, returnType);
}
@@ -2864,6 +2883,25 @@ public class VectorizationContext {
return null;
}
+ private VectorExpression getCastToBinary(List<ExprNodeDesc> childExpr, TypeInfo returnType)
+ throws HiveException {
+ ExprNodeDesc child = childExpr.get(0);
+ String inputType = childExpr.get(0).getTypeString();
+ if (child instanceof ExprNodeConstantDesc) {
+ // Don't do constant folding here. Wait until the optimizer is changed to do it.
+ // Family of related JIRAs: HIVE-7421, HIVE-7422, and HIVE-7424.
+ return null;
+ }
+ if (inputType.equalsIgnoreCase("string") || varcharTypePattern.matcher(inputType).matches()) {
+
+ // STRING and VARCHAR types require no conversion, so use a no-op.
+ return getIdentityExpression(childExpr);
+ } else if (charTypePattern.matcher(inputType).matches()) {
+ return createVectorExpression(CastCharToBinary.class, childExpr, VectorExpressionDescriptor.Mode.PROJECTION, returnType);
+ }
+ return null;
+ }
+
private VectorExpression getCastToDoubleExpression(Class<?> udf, List<ExprNodeDesc> childExpr,
TypeInfo returnType) throws HiveException {
ExprNodeDesc child = childExpr.get(0);