http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalar.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalar.txt index f744d9b..bab8508 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalar.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalar.txt @@ -20,24 +20,130 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; - +import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; +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; /** - * Generated from template FilterTimestampColumnCompareScalar.txt, which covers comparison - * expressions between a datetime/interval column and a scalar of the same type, however output is not - * produced in a separate column. + * Generated from template FilterColumnCompareScalar.txt, which covers binary 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> { +public class <ClassName> extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private <HiveOperandType> value; - public <ClassName>(int colNum, Timestamp value) { - super(colNum, new PisaTimestamp(value)); + public <ClassName>(int colNum, <HiveOperandType> value) { + this.colNum = colNum; + this.value = value; } public <ClassName>() { - super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + // Input #1 is type <OperandType>. + <InputColumnVectorType> inputColVector1 = (<InputColumnVectorType>) batch.cols[colNum]; + + int[] sel = batch.selected; + boolean[] nullPos = inputColVector1.isNull; + int n = batch.size; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector1.noNulls) { + if (inputColVector1.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!(inputColVector1.compareTo(0, value) <OperatorSymbol> 0)) { + //Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (inputColVector1.compareTo(i, value) <OperatorSymbol> 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (inputColVector1.compareTo(i, value) <OperatorSymbol> 0) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector1.isRepeating) { + //All must be selected otherwise size would be zero + //Repeating property will not change. + if (!nullPos[0]) { + if (!(inputColVector1.compareTo(0, value) <OperatorSymbol> 0)) { + //Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j=0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (inputColVector1.compareTo(i, value) <OperatorSymbol> 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 (inputColVector1.compareTo(i, value) <OperatorSymbol> 0) { + sel[newSize++] = i; + } + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; } @Override @@ -47,8 +153,8 @@ public class <ClassName> extends <BaseClassName> { VectorExpressionDescriptor.Mode.FILTER) .setNumArguments(2) .setArgumentTypes( - VectorExpressionDescriptor.ArgumentType.getType("timestamp"), - VectorExpressionDescriptor.ArgumentType.getType("timestamp")) + VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"), + VectorExpressionDescriptor.ArgumentType.getType("<OperandType>")) .setInputExpressionTypes( VectorExpressionDescriptor.InputExpressionType.COLUMN, VectorExpressionDescriptor.InputExpressionType.SCALAR).build();
http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalarBase.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalarBase.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalarBase.txt deleted file mode 100644 index c84b4bf..0000000 --- a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampColumnCompareTimestampScalarBase.txt +++ /dev/null @@ -1,145 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; - -import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; - -import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; -import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; -import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; -import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; - -/** - * Generated from template FilterColumnCompareScalar.txt, which covers binary 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 abstract class <ClassName> extends VectorExpression { - - private static final long serialVersionUID = 1L; - - private int colNum; - private PisaTimestamp value; - - public <ClassName>(int colNum, PisaTimestamp value) { - this.colNum = colNum; - this.value = value; - } - - public <ClassName>() { - } - - @Override - public void evaluate(VectorizedRowBatch batch) { - - 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; - } - - if (inputColVector.noNulls) { - if (inputColVector.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. - if (!(inputColVector.compareTo(0, value) <OperatorSymbol> 0)) { - //Entire batch is filtered out. - batch.size = 0; - } - } else if (batch.selectedInUse) { - int newSize = 0; - for(int j=0; j != n; j++) { - int i = sel[j]; - if (inputColVector.compareTo(i, value) <OperatorSymbol> 0) { - sel[newSize++] = i; - } - } - batch.size = newSize; - } else { - int newSize = 0; - for(int i = 0; i != n; i++) { - if (inputColVector.compareTo(i, value) <OperatorSymbol> 0) { - sel[newSize++] = i; - } - } - if (newSize < n) { - batch.size = newSize; - batch.selectedInUse = true; - } - } - } else { - if (inputColVector.isRepeating) { - //All must be selected otherwise size would be zero - //Repeating property will not change. - if (!nullPos[0]) { - if (!(inputColVector.compareTo(0, value) <OperatorSymbol> 0)) { - //Entire batch is filtered out. - batch.size = 0; - } - } else { - batch.size = 0; - } - } else if (batch.selectedInUse) { - int newSize = 0; - for(int j=0; j != n; j++) { - int i = sel[j]; - if (!nullPos[i]) { - if (inputColVector.compareTo(i, value) <OperatorSymbol> 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 (inputColVector.compareTo(i, value) <OperatorSymbol> 0) { - sel[newSize++] = i; - } - } - } - if (newSize < n) { - batch.size = newSize; - batch.selectedInUse = true; - } - } - } - } - - @Override - public int getOutputColumn() { - return -1; - } - - @Override - public String getOutputType() { - return "boolean"; - } -} http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareLongDoubleColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareLongDoubleColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareLongDoubleColumn.txt index c3cd3b4..5e418de 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareLongDoubleColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareLongDoubleColumn.txt @@ -19,7 +19,6 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; import org.apache.hadoop.hive.ql.exec.vector.*; @@ -36,7 +35,7 @@ public class <ClassName> extends <BaseClassName> { private static final long serialVersionUID = 1L; public <ClassName>(Timestamp value, int colNum) { - super(new PisaTimestamp(value).<GetTimestampLongDoubleMethod>(), colNum); + super(TimestampColumnVector.<GetTimestampLongDoubleMethod>(value), colNum); } public <ClassName>() { http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumn.txt index 05ab310..ff5d11e 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumn.txt @@ -20,24 +20,132 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; - +import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; +import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; +import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; +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.serde2.io.HiveDecimalWritable; +import org.apache.hadoop.hive.common.type.HiveDecimal; /** - * Generated from template FilterTimestampScalarCompareTimestampColumn.txt, which covers comparison - * expressions between a datetime/interval column and a scalar of the same type, however output is not - * produced in a separate column. - * The selected vector of the input {@link VectorizedRowBatch} is updated for in-place filtering. + * This is a generated class to evaluate a <OperatorSymbol> comparison on a vector of timestamp + * values. */ -public class <ClassName> extends <BaseClassName> { +public class <ClassName> extends VectorExpression { + + private static final long serialVersionUID = 1L; + + private int colNum; + private <HiveOperandType> value; - public <ClassName>(Timestamp value, int colNum) { - super(new PisaTimestamp(value), colNum); + public <ClassName>(<HiveOperandType> value, int colNum) { + this.colNum = colNum; + this.value = value; } public <ClassName>() { - super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + if (childExpressions != null) { + super.evaluateChildren(batch); + } + // Input #2 is type <OperandType>. + <InputColumnVectorType> inputColVector2 = (<InputColumnVectorType>) batch.cols[colNum]; + + int[] sel = batch.selected; + boolean[] nullPos = inputColVector2.isNull; + int n = batch.size; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector2.noNulls) { + if (inputColVector2.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!(inputColVector2.compareTo(value, 0) <OperatorSymbol> 0)) { + + // Entire batch is filtered out. + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (inputColVector2.compareTo(value, i) <OperatorSymbol> 0) { + sel[newSize++] = i; + } + } + batch.size = newSize; + } else { + int newSize = 0; + for(int i = 0; i != n; i++) { + if (inputColVector2.compareTo(value, i) <OperatorSymbol> 0) { + sel[newSize++] = i; + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } else { + if (inputColVector2.isRepeating) { + + // All must be selected otherwise size would be zero. Repeating property will not change. + if (!nullPos[0]) { + if (!(inputColVector2.compareTo(value, 0) <OperatorSymbol> 0)) { + + // Entire batch is filtered out. + batch.size = 0; + } + } else { + batch.size = 0; + } + } else if (batch.selectedInUse) { + int newSize = 0; + for(int j = 0; j != n; j++) { + int i = sel[j]; + if (!nullPos[i]) { + if (inputColVector2.compareTo(value, i) <OperatorSymbol> 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 (inputColVector2.compareTo(value, i) <OperatorSymbol> 0) { + sel[newSize++] = i; + } + } + } + if (newSize < n) { + batch.size = newSize; + batch.selectedInUse = true; + } + } + } + } + + @Override + public int getOutputColumn() { + return -1; + } + + @Override + public String getOutputType() { + return "boolean"; } @Override @@ -47,8 +155,8 @@ public class <ClassName> extends <BaseClassName> { VectorExpressionDescriptor.Mode.FILTER) .setNumArguments(2) .setArgumentTypes( - VectorExpressionDescriptor.ArgumentType.getType("timestamp"), - VectorExpressionDescriptor.ArgumentType.getType("timestamp")) + VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"), + VectorExpressionDescriptor.ArgumentType.getType("<OperandType>")) .setInputExpressionTypes( VectorExpressionDescriptor.InputExpressionType.SCALAR, VectorExpressionDescriptor.InputExpressionType.COLUMN).build(); http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumnBase.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumnBase.txt b/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumnBase.txt deleted file mode 100644 index 608faef..0000000 --- a/ql/src/gen/vectorization/ExpressionTemplates/FilterTimestampScalarCompareTimestampColumnBase.txt +++ /dev/null @@ -1,147 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; - -import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; - -import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; -import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; -import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; -import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; -import org.apache.hadoop.hive.serde2.io.HiveDecimalWritable; -import org.apache.hadoop.hive.common.type.HiveDecimal; - -/** - * This is a generated class to evaluate a <OperatorSymbol> comparison on a vector of timestamp - * values. - */ -public abstract class <ClassName> extends VectorExpression { - - private static final long serialVersionUID = 1L; - - private int colNum; - private PisaTimestamp value; - - public <ClassName>(PisaTimestamp value, int colNum) { - this.colNum = colNum; - this.value = value; - } - - public <ClassName>() { - } - - @Override - public void evaluate(VectorizedRowBatch batch) { - 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; - } - - if (inputColVector.noNulls) { - if (inputColVector.isRepeating) { - - // All must be selected otherwise size would be zero. Repeating property will not change. - if (!(inputColVector.compareTo(value, 0) <OperatorSymbol> 0)) { - - // Entire batch is filtered out. - batch.size = 0; - } - } else if (batch.selectedInUse) { - int newSize = 0; - for(int j = 0; j != n; j++) { - int i = sel[j]; - if (inputColVector.compareTo(value, i) <OperatorSymbol> 0) { - sel[newSize++] = i; - } - } - batch.size = newSize; - } else { - int newSize = 0; - for(int i = 0; i != n; i++) { - if (inputColVector.compareTo(value, i) <OperatorSymbol> 0) { - sel[newSize++] = i; - } - } - if (newSize < n) { - batch.size = newSize; - batch.selectedInUse = true; - } - } - } else { - if (inputColVector.isRepeating) { - - // All must be selected otherwise size would be zero. Repeating property will not change. - if (!nullPos[0]) { - if (!(inputColVector.compareTo(value, 0) <OperatorSymbol> 0)) { - - // Entire batch is filtered out. - batch.size = 0; - } - } else { - batch.size = 0; - } - } else if (batch.selectedInUse) { - int newSize = 0; - for(int j = 0; j != n; j++) { - int i = sel[j]; - if (!nullPos[i]) { - if (inputColVector.compareTo(value, i) <OperatorSymbol> 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 (inputColVector.compareTo(value, i) <OperatorSymbol> 0) { - sel[newSize++] = i; - } - } - } - if (newSize < n) { - batch.size = newSize; - batch.selectedInUse = true; - } - } - } - } - - @Override - public int getOutputColumn() { - return -1; - } - - @Override - public String getOutputType() { - return "boolean"; - } -} http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeColumn.txt deleted file mode 100644 index bf62b78..0000000 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeColumn.txt +++ /dev/null @@ -1,54 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; - -import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; - - -/** - * Generated from template IntervalDayTimeColumnCompareColumn.txt, which covers comparison - * expressions between a datetime/interval column and a scalar of the same type. The boolean output - * is stored in a separate boolean column. - */ -public class <ClassName> extends <BaseClassName> { - - private static final long serialVersionUID = 1L; - - public <ClassName>(int colNum1, int colNum2, int outputColumn) { - super(colNum1, colNum2, outputColumn); - } - - public <ClassName>() { - super(); - } - - @Override - public VectorExpressionDescriptor.Descriptor getDescriptor() { - return (new VectorExpressionDescriptor.Builder()) - .setMode( - VectorExpressionDescriptor.Mode.PROJECTION) - .setNumArguments(2) - .setArgumentTypes( - VectorExpressionDescriptor.ArgumentType.getType("interval_day_time"), - VectorExpressionDescriptor.ArgumentType.getType("interval_day_time")) - .setInputExpressionTypes( - VectorExpressionDescriptor.InputExpressionType.COLUMN, - VectorExpressionDescriptor.InputExpressionType.COLUMN).build(); - } -} http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeScalar.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeScalar.txt deleted file mode 100644 index 1abb4a3..0000000 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeColumnCompareIntervalDayTimeScalar.txt +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; - -import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; -import org.apache.hadoop.hive.common.type.PisaTimestamp; - -import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; - - -/** - * Generated from template IntervalDayTimeColumnCompareScalar.txt, which covers comparison - * expressions between a datetime/interval column and a scalar of the same type. The boolean output - * is stored in a separate boolean column. - */ -public class <ClassName> extends <BaseClassName> { - - private static final long serialVersionUID = 1L; - - public <ClassName>(int colNum, HiveIntervalDayTime value, int outputColumn) { - super(colNum, value.pisaTimestampUpdate(new PisaTimestamp()), outputColumn); - } - - public <ClassName>() { - super(); - } - - @Override - public VectorExpressionDescriptor.Descriptor getDescriptor() { - return (new VectorExpressionDescriptor.Builder()) - .setMode( - VectorExpressionDescriptor.Mode.PROJECTION) - .setNumArguments(2) - .setArgumentTypes( - VectorExpressionDescriptor.ArgumentType.getType("interval_day_time"), - VectorExpressionDescriptor.ArgumentType.getType("interval_day_time")) - .setInputExpressionTypes( - VectorExpressionDescriptor.InputExpressionType.COLUMN, - VectorExpressionDescriptor.InputExpressionType.SCALAR).build(); - } -} http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeScalarCompareIntervalDayTimeColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeScalarCompareIntervalDayTimeColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeScalarCompareIntervalDayTimeColumn.txt deleted file mode 100644 index 26762ff..0000000 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalDayTimeScalarCompareIntervalDayTimeColumn.txt +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; - -import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; -import org.apache.hadoop.hive.common.type.PisaTimestamp; - -import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; - - -/** - * Generated from template IntervalDayTimeColumnCompareScalar.txt, which covers comparison - * expressions between a datetime/interval column and a scalar of the same type. The boolean output - * is stored in a separate boolean column. - */ -public class <ClassName> extends <BaseClassName> { - - private static final long serialVersionUID = 1L; - - public <ClassName>(HiveIntervalDayTime value, int colNum, int outputColumn) { - super(value.pisaTimestampUpdate(new PisaTimestamp()), colNum, outputColumn); - } - - public <ClassName>() { - super(); - } - - @Override - public VectorExpressionDescriptor.Descriptor getDescriptor() { - return (new VectorExpressionDescriptor.Builder()) - .setMode( - VectorExpressionDescriptor.Mode.PROJECTION) - .setNumArguments(2) - .setArgumentTypes( - VectorExpressionDescriptor.ArgumentType.getType("interval_day_time"), - VectorExpressionDescriptor.ArgumentType.getType("interval_day_time")) - .setInputExpressionTypes( - VectorExpressionDescriptor.InputExpressionType.SCALAR, - VectorExpressionDescriptor.InputExpressionType.COLUMN).build(); - } -} http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateColumn.txt index 7ae84b7..8e3a419 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateColumn.txt @@ -18,12 +18,15 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; +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.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.util.DateTimeMath; +import org.apache.hadoop.hive.serde2.io.DateWritable; /** * Generated from template DateColumnArithmeticIntervalYearMonthColumn.txt, which covers binary arithmetic @@ -36,12 +39,18 @@ public class <ClassName> extends VectorExpression { private int colNum1; private int colNum2; private int outputColumn; + private HiveIntervalYearMonth scratchIntervalYearMonth1; + private Date scratchDate2; + private Date outputDate; private DateTimeMath dtm = new DateTimeMath(); public <ClassName>(int colNum1, int colNum2, int outputColumn) { this.colNum1 = colNum1; this.colNum2 = colNum2; this.outputColumn = outputColumn; + scratchIntervalYearMonth1 = new HiveIntervalYearMonth(); + scratchDate2 = new Date(0); + outputDate = new Date(0); } public <ClassName>() { @@ -54,10 +63,10 @@ public class <ClassName> extends VectorExpression { super.evaluateChildren(batch); } - // Input #1 is type interval_year_month (months). + // Input #1 is type interval_year_month. LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; - // Input #2 is type date (epochDays). + // Input #2 is type date. LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum2]; // Output is type date. @@ -89,40 +98,64 @@ public class <ClassName> extends VectorExpression { * conditional checks in the inner loop. */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - outputVector[0] = dtm.addMonthsToDays(vector2[0], <OperatorSymbol> (int) vector1[0]); + scratchIntervalYearMonth1.set((int) vector1[0]); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[0])); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[0] = DateWritable.dateToDays(outputDate); } else if (inputColVector1.isRepeating) { - long value1 = vector1[0]; + scratchIntervalYearMonth1.set((int) vector1[0]); if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(vector2[i], <OperatorSymbol> (int) value1); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(vector2[i], <OperatorSymbol> (int) value1); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } } else if (inputColVector2.isRepeating) { - long value2 = vector2[0]; + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[0])); if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(value2, <OperatorSymbol> (int) vector1[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(value2, <OperatorSymbol> (int) vector1[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(vector2[i], <OperatorSymbol> (int) vector1[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(vector2[i], <OperatorSymbol> (int) vector1[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateScalar.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateScalar.txt index 2f2522d..ad65d52 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateScalar.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticDateScalar.txt @@ -18,6 +18,8 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; +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; import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; @@ -25,6 +27,7 @@ import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil; import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; import org.apache.hadoop.hive.ql.exec.vector.*; import org.apache.hadoop.hive.ql.util.DateTimeMath; +import org.apache.hadoop.hive.serde2.io.DateWritable; /** * Generated from template DateColumnArithmeticIntervalYearMonthScalar.txt, which covers binary arithmetic @@ -35,14 +38,18 @@ public class <ClassName> extends VectorExpression { private static final long serialVersionUID = 1L; private int colNum; - private long value; + private Date value; private int outputColumn; + private HiveIntervalYearMonth scratchIntervalYearMonth1; + private Date outputDate; private DateTimeMath dtm = new DateTimeMath(); public <ClassName>(int colNum, long value, int outputColumn) { this.colNum = colNum; - this.value = value; + this.value = new Date(DateWritable.daysToMillis((int) value)); this.outputColumn = outputColumn; + scratchIntervalYearMonth1 = new HiveIntervalYearMonth(); + outputDate = new Date(0); } public <ClassName>() { @@ -56,18 +63,18 @@ public class <ClassName> extends VectorExpression { } // Input #1 is type interval_year_mont (epochMonths). - LongColumnVector inputColVector = (LongColumnVector) batch.cols[colNum]; + LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum]; // Output is type date. LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumn]; int[] sel = batch.selected; - boolean[] inputIsNull = inputColVector.isNull; + boolean[] inputIsNull = inputColVector1.isNull; boolean[] outputIsNull = outputColVector.isNull; - outputColVector.noNulls = inputColVector.noNulls; - outputColVector.isRepeating = inputColVector.isRepeating; + outputColVector.noNulls = inputColVector1.noNulls; + outputColVector.isRepeating = inputColVector1.isRepeating; int n = batch.size; - long[] vector = inputColVector.vector; + long[] vector1 = inputColVector1.vector; long[] outputVector = outputColVector.vector; // return immediately if batch is empty @@ -75,32 +82,46 @@ public class <ClassName> extends VectorExpression { return; } - if (inputColVector.isRepeating) { - outputVector[0] = dtm.addMonthsToDays(value, <OperatorSymbol> (int) vector[0]); - + if (inputColVector1.isRepeating) { + scratchIntervalYearMonth1.set((int) vector1[0]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, 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 (inputColVector.noNulls) { + } else if (inputColVector1.noNulls) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(value, <OperatorSymbol> (int) vector[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(value, <OperatorSymbol> (int) vector[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } } else /* there are nulls */ { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(value, <OperatorSymbol> (int) vector[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); outputIsNull[i] = inputIsNull[i]; } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(value, <OperatorSymbol> (int) vector[i]); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampColumn.txt index b3da89f..858c3d7 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampColumn.txt @@ -18,7 +18,9 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; -import org.apache.hadoop.hive.common.type.PisaTimestamp; +import java.sql.Timestamp; + +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.expressions.NullUtil; import org.apache.hadoop.hive.ql.exec.vector.*; @@ -37,14 +39,14 @@ public class <ClassName> extends VectorExpression { private int colNum1; private int colNum2; private int outputColumn; - private PisaTimestamp scratchPisaTimestamp; + private HiveIntervalYearMonth scratchIntervalYearMonth1; private DateTimeMath dtm = new DateTimeMath(); public <ClassName>(int colNum1, int colNum2, int outputColumn) { this.colNum1 = colNum1; this.colNum2 = colNum2; this.outputColumn = outputColumn; - scratchPisaTimestamp = new PisaTimestamp(); + scratchIntervalYearMonth1 = new HiveIntervalYearMonth(); } public <ClassName>() { @@ -57,10 +59,10 @@ public class <ClassName> extends VectorExpression { super.evaluateChildren(batch); } - // Input #1 is type Interval_Year_Month (months). + // Input #1 is type Interval_Year_Month. LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1]; - // Input #2 is type Timestamp (PisaTimestamp). + // Input #2 is type Timestamp. TimestampColumnVector inputColVector2 = (TimestampColumnVector) batch.cols[colNum2]; // Output is type Timestamp. @@ -91,54 +93,59 @@ public class <ClassName> extends VectorExpression { * conditional checks in the inner loop. */ if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - outputColVector.set(0, - dtm.addMonthsToPisaTimestamp(inputColVector2.asScratchPisaTimestamp(0), <OperatorSymbol> (int) vector1[0], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[0]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(0), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(0); } else if (inputColVector1.isRepeating) { - long value1 = vector1[0]; + scratchIntervalYearMonth1.set((int) vector1[0]); if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector2.asScratchPisaTimestamp(i), <OperatorSymbol> (int) value1, - scratchPisaTimestamp)); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector2.asScratchPisaTimestamp(i), <OperatorSymbol> (int) value1, - scratchPisaTimestamp)); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } } else if (inputColVector2.isRepeating) { - PisaTimestamp value2 = inputColVector2.asScratchPisaTimestamp(0); + Timestamp value2 = inputColVector2.asScratchTimestamp(0); if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(value2, <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(value2, <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } } else { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector2.asScratchPisaTimestamp(i), <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector2.asScratchPisaTimestamp(i), <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampScalar.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampScalar.txt index 81f2a77..66fffd2 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampScalar.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthColumnArithmeticTimestampScalar.txt @@ -20,7 +20,7 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; +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.TimestampColumnVector; import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; @@ -38,16 +38,16 @@ public class <ClassName> extends VectorExpression { private static final long serialVersionUID = 1L; private int colNum; - private PisaTimestamp value; + private Timestamp value; private int outputColumn; - private PisaTimestamp scratchPisaTimestamp; + private HiveIntervalYearMonth scratchIntervalYearMonth1; private DateTimeMath dtm = new DateTimeMath(); public <ClassName>(int colNum, Timestamp value, int outputColumn) { this.colNum = colNum; - this.value = new PisaTimestamp(value); + this.value = value; this.outputColumn = outputColumn; - scratchPisaTimestamp = new PisaTimestamp(); + scratchIntervalYearMonth1 = new HiveIntervalYearMonth(); } public <ClassName>() { @@ -60,7 +60,7 @@ public class <ClassName> extends VectorExpression { super.evaluateChildren(batch); } - // Input #1 is type interval_year_month (epochMonths). + // Input #1 is type interval_year_month. LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum]; // Output is type Timestamp. @@ -81,41 +81,45 @@ public class <ClassName> extends VectorExpression { } if (inputColVector1.isRepeating) { - outputColVector.set(0, - dtm.addMonthsToPisaTimestamp(value, <OperatorSymbol> (int) vector1[0], - scratchPisaTimestamp)); - + scratchIntervalYearMonth1.set((int) vector1[0]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(0); // Even if there are no nulls, we always copy over entry 0. Simplifies code. outputIsNull[0] = inputIsNull[0]; } else if (inputColVector1.noNulls) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(value, <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(value, <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } } else /* there are nulls */ { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(value, <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); outputIsNull[i] = inputIsNull[i]; } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(value, <OperatorSymbol> (int) vector1[i], - scratchPisaTimestamp)); + scratchIntervalYearMonth1.set((int) vector1[i]); + dtm.<OperatorMethod>( + scratchIntervalYearMonth1, value, outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticDateColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticDateColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticDateColumn.txt index 3f4f05f..ddde913 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticDateColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticDateColumn.txt @@ -18,6 +18,8 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; +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.VectorExpressionDescriptor; import org.apache.hadoop.hive.ql.exec.vector.*; @@ -33,6 +35,7 @@ import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector; 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.util.DateTimeMath; +import org.apache.hadoop.hive.serde2.io.DateWritable; /** * Generated from template DateTimeScalarArithmeticIntervalYearMonthColumn.txt. @@ -44,14 +47,18 @@ public class <ClassName> extends VectorExpression { private static final long serialVersionUID = 1L; private int colNum; - private long value; + private HiveIntervalYearMonth value; private int outputColumn; + private Date scratchDate2; + private Date outputDate; private DateTimeMath dtm = new DateTimeMath(); public <ClassName>(long value, int colNum, int outputColumn) { this.colNum = colNum; - this.value = value; + this.value = new HiveIntervalYearMonth((int) value); this.outputColumn = outputColumn; + scratchDate2 = new Date(0); + outputDate = new Date(0); } public <ClassName>() { @@ -70,18 +77,18 @@ public class <ClassName> extends VectorExpression { } // Input #2 is type date. - LongColumnVector inputColVector = (LongColumnVector) batch.cols[colNum]; + LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum]; // Output is type Date. LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumn]; int[] sel = batch.selected; - boolean[] inputIsNull = inputColVector.isNull; + boolean[] inputIsNull = inputColVector2.isNull; boolean[] outputIsNull = outputColVector.isNull; - outputColVector.noNulls = inputColVector.noNulls; - outputColVector.isRepeating = inputColVector.isRepeating; + outputColVector.noNulls = inputColVector2.noNulls; + outputColVector.isRepeating = inputColVector2.isRepeating; int n = batch.size; - long[] vector = inputColVector.vector; + long[] vector2 = inputColVector2.vector; long[] outputVector = outputColVector.vector; // return immediately if batch is empty @@ -89,32 +96,46 @@ public class <ClassName> extends VectorExpression { return; } - if (inputColVector.isRepeating) { - outputVector[0] = dtm.addMonthsToDays(vector[0], <OperatorSymbol> (int) value); - + if (inputColVector2.isRepeating) { + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[0])); + dtm.<OperatorMethod>( + value, scratchDate2, 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 (inputColVector.noNulls) { + } else if (inputColVector2.noNulls) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(vector[i], <OperatorSymbol> (int) value); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + value, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(vector[i], <OperatorSymbol> (int) value); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + value, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } } } else { /* there are nulls */ if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputVector[i] = dtm.addMonthsToDays(vector[i], <OperatorSymbol> (int) value); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + value, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); outputIsNull[i] = inputIsNull[i]; } } else { for(int i = 0; i != n; i++) { - outputVector[i] = dtm.addMonthsToDays(vector[i], <OperatorSymbol> (int) value); + scratchDate2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + value, scratchDate2, outputDate); + outputVector[i] = DateWritable.dateToDays(outputDate); } System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticTimestampColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticTimestampColumn.txt index 47d611e..cbb7021 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticTimestampColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/IntervalYearMonthScalarArithmeticTimestampColumn.txt @@ -18,11 +18,13 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; +import java.sql.Timestamp; + +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; import org.apache.hadoop.hive.ql.exec.vector.*; -import org.apache.hadoop.hive.common.type.PisaTimestamp; /* * Because of the templatized nature of the code, either or both * of these ColumnVector imports may be needed. Listing both of them @@ -44,16 +46,14 @@ public class <ClassName> extends VectorExpression { private static final long serialVersionUID = 1L; private int colNum; - private long value; + private HiveIntervalYearMonth value; private int outputColumn; - private PisaTimestamp scratchPisaTimestamp; private DateTimeMath dtm = new DateTimeMath(); public <ClassName>(long value, int colNum, int outputColumn) { this.colNum = colNum; - this.value = value; + this.value = new HiveIntervalYearMonth((int) value); this.outputColumn = outputColumn; - scratchPisaTimestamp = new PisaTimestamp(); } public <ClassName>() { @@ -72,16 +72,16 @@ public class <ClassName> extends VectorExpression { } // Input #2 is type timestamp. - TimestampColumnVector inputColVector = (TimestampColumnVector) batch.cols[colNum]; + TimestampColumnVector inputColVector2 = (TimestampColumnVector) batch.cols[colNum]; - // Output is type Timestamp. + // Output is type Timestamp. TimestampColumnVector outputColVector = (TimestampColumnVector) batch.cols[outputColumn]; int[] sel = batch.selected; - boolean[] inputIsNull = inputColVector.isNull; + boolean[] inputIsNull = inputColVector2.isNull; boolean[] outputIsNull = outputColVector.isNull; - outputColVector.noNulls = inputColVector.noNulls; - outputColVector.isRepeating = inputColVector.isRepeating; + outputColVector.noNulls = inputColVector2.noNulls; + outputColVector.isRepeating = inputColVector2.isRepeating; int n = batch.size; // return immediately if batch is empty @@ -89,42 +89,41 @@ public class <ClassName> extends VectorExpression { return; } - if (inputColVector.isRepeating) { - outputColVector.set(0, - dtm.addMonthsToPisaTimestamp(inputColVector.asScratchPisaTimestamp(0), <OperatorSymbol> (int) value, - scratchPisaTimestamp)); - + if (inputColVector2.isRepeating) { + dtm.<OperatorMethod>( + value, inputColVector2.asScratchTimestamp(0), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(0); // Even if there are no nulls, we always copy over entry 0. Simplifies code. outputIsNull[0] = inputIsNull[0]; - } else if (inputColVector.noNulls) { + } else if (inputColVector2.noNulls) { if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector.asScratchPisaTimestamp(i), <OperatorSymbol> (int) value, - scratchPisaTimestamp)); + dtm.<OperatorMethod>( + value, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector.asScratchPisaTimestamp(i), <OperatorSymbol> (int) value, - scratchPisaTimestamp)); + dtm.<OperatorMethod>( + value, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } } } else { /* there are nulls */ if (batch.selectedInUse) { for(int j = 0; j != n; j++) { int i = sel[j]; - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector.asScratchPisaTimestamp(i), <OperatorSymbol> (int) value, - scratchPisaTimestamp)); + dtm.<OperatorMethod>( + value, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); outputIsNull[i] = inputIsNull[i]; } } else { for(int i = 0; i != n; i++) { - outputColVector.set(i, - dtm.addMonthsToPisaTimestamp(inputColVector.asScratchPisaTimestamp(i), <OperatorSymbol> (int) value, - scratchPisaTimestamp)); + dtm.<OperatorMethod>( + value, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp()); + outputColVector.setFromScratchTimestamp(i); } System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampColumn.txt index e804e2a..9ccfaac 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampColumn.txt @@ -19,7 +19,6 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil; http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampScalar.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampScalar.txt index 90720ba..c7d8c65 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampScalar.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampScalar.txt @@ -19,7 +19,6 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import java.sql.Timestamp; -import org.apache.hadoop.hive.common.type.PisaTimestamp; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; import org.apache.hadoop.hive.ql.exec.vector.*; @@ -41,7 +40,7 @@ public class <ClassName> extends VectorExpression { public <ClassName>(int colNum, Timestamp value, int outputColumn) { this.colNum = colNum; - this.value = new PisaTimestamp(value).<GetTimestampLongDoubleMethod>(); + this.value = TimestampColumnVector.<GetTimestampLongDoubleMethod>(value); this.outputColumn = outputColumn; } http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleScalarCompareTimestampColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleScalarCompareTimestampColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleScalarCompareTimestampColumn.txt index 7d3856a..d47bc10 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleScalarCompareTimestampColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/LongDoubleScalarCompareTimestampColumn.txt @@ -21,6 +21,7 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; 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; http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumn.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumn.txt b/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumn.txt index b086a88..27e083d 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumn.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumn.txt @@ -18,28 +18,156 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; -import org.apache.hadoop.hive.common.type.PisaTimestamp; +import java.sql.Timestamp; + +import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; 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.util.DateTimeMath; +import org.apache.hadoop.hive.serde2.io.DateWritable; /** * Generated from template TimestampColumnArithmeticDateColumn.txt, which covers binary arithmetic * expressions between columns. */ -public class <ClassName> extends <BaseClassName> { +public class <ClassName> extends VectorExpression { private static final long serialVersionUID = 1L; + private int colNum1; + private int colNum2; + private int outputColumn; + private Timestamp scratchTimestamp2; + private DateTimeMath dtm = new DateTimeMath(); + public <ClassName>(int colNum1, int colNum2, int outputColumn) { - super(colNum1, colNum2, outputColumn); + this.colNum1 = colNum1; + this.colNum2 = colNum2; + this.outputColumn = outputColumn; + scratchTimestamp2 = new Timestamp(0); } public <ClassName>() { - super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + // Input #1 is type <OperandType1>. + <InputColumnVectorType1> inputColVector1 = (<InputColumnVectorType1>) batch.cols[colNum1]; + + // Input #2 is type date (days). For the math we convert it to a timestamp. + LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum2]; + + // Output is type <ReturnType>. + <OutputColumnVectorType> outputColVector = (<OutputColumnVectorType>) batch.cols[outputColumn]; + + int[] sel = batch.selected; + int n = batch.size; + + long[] vector2 = inputColVector2.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]; + + // Handle nulls first + NullUtil.propagateNullsColCol( + inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse); + + /* Disregard nulls for processing. In other words, + * the arithmetic operation is performed even if one or + * more inputs are null. This is to improve speed by avoiding + * conditional checks in the inner loop. + */ + if (inputColVector1.isRepeating && inputColVector2.isRepeating) { + scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[0])); + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(0), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(0); + } else if (inputColVector1.isRepeating) { + <HiveOperandType1> value1 = inputColVector1.asScratch<CamelOperandType1>(0); + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + value1, scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } else { + for(int i = 0; i != n; i++) { + scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + value1, scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } + } else if (inputColVector2.isRepeating) { + scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[0])); + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } else { + for(int i = 0; i != n; i++) { + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } + } else { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } else { + for(int i = 0; i != n; i++) { + scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i])); + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } + } + + /* 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.setNullDataEntries<CamelReturnType>(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "interval_day_time"; } @Override @@ -50,7 +178,7 @@ public class <ClassName> extends <BaseClassName> { .setNumArguments(2) .setArgumentTypes( VectorExpressionDescriptor.ArgumentType.getType("<OperandType1>"), - VectorExpressionDescriptor.ArgumentType.getType("<OperandType2>")) + VectorExpressionDescriptor.ArgumentType.getType("date")) .setInputExpressionTypes( VectorExpressionDescriptor.InputExpressionType.COLUMN, VectorExpressionDescriptor.InputExpressionType.COLUMN).build(); http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumnBase.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumnBase.txt b/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumnBase.txt deleted file mode 100644 index 7f5496c..0000000 --- a/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateColumnBase.txt +++ /dev/null @@ -1,172 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; - -import org.apache.hadoop.hive.common.type.PisaTimestamp; -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.serde2.io.DateWritable; - -/** - * Generated from template TimestampColumnArithmeticDateColumnBase.txt, which covers binary arithmetic - * expressions between columns. - */ -public abstract class <BaseClassName> extends VectorExpression { - - private static final long serialVersionUID = 1L; - - private int colNum1; - private int colNum2; - private int outputColumn; - private PisaTimestamp scratchPisaTimestamp; - - public <BaseClassName>(int colNum1, int colNum2, int outputColumn) { - this.colNum1 = colNum1; - this.colNum2 = colNum2; - this.outputColumn = outputColumn; - scratchPisaTimestamp = new PisaTimestamp(); - } - - public <BaseClassName>() { - } - - @Override - public void evaluate(VectorizedRowBatch batch) { - - if (childExpressions != null) { - super.evaluateChildren(batch); - } - - // Input #1 is type timestamp (PisaTimestamp). - TimestampColumnVector inputColVector1 = (TimestampColumnVector) batch.cols[colNum1]; - - // Input #2 is type date. - LongColumnVector inputColVector2 = (LongColumnVector) batch.cols[colNum2]; - - // Output is type timestamp. - TimestampColumnVector outputColVector = (TimestampColumnVector) batch.cols[outputColumn]; - - int[] sel = batch.selected; - int n = batch.size; - - long[] vector2 = inputColVector2.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]; - - // Handle nulls first - NullUtil.propagateNullsColCol( - inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse); - - /* Disregard nulls for processing. In other words, - * the arithmetic operation is performed even if one or - * more inputs are null. This is to improve speed by avoiding - * conditional checks in the inner loop. - */ - if (inputColVector1.isRepeating && inputColVector2.isRepeating) { - outputColVector.<OperatorMethod>( - inputColVector1.asScratchPisaTimestamp(0), - scratchPisaTimestamp.updateFromTimestampMilliseconds(DateWritable.daysToMillis((int) vector2[0])), - 0); - } else if (inputColVector1.isRepeating) { - PisaTimestamp value1 = inputColVector1.asScratchPisaTimestamp(0); - if (batch.selectedInUse) { - for(int j = 0; j != n; j++) { - int i = sel[j]; - outputColVector.<OperatorMethod>( - value1, - scratchPisaTimestamp.updateFromTimestampMilliseconds(DateWritable.daysToMillis((int) vector2[i])), - i); - } - } else { - for(int i = 0; i != n; i++) { - outputColVector.<OperatorMethod>( - value1, - scratchPisaTimestamp.updateFromTimestampMilliseconds(DateWritable.daysToMillis((int) vector2[i])), - i); - } - } - } else if (inputColVector2.isRepeating) { - PisaTimestamp value2 = - scratchPisaTimestamp.updateFromTimestampMilliseconds(DateWritable.daysToMillis((int) vector2[0])); - if (batch.selectedInUse) { - for(int j = 0; j != n; j++) { - int i = sel[j]; - outputColVector.<OperatorMethod>( - inputColVector1.asScratchPisaTimestamp(i), - value2, - i); - } - } else { - for(int i = 0; i != n; i++) { - outputColVector.<OperatorMethod>( - inputColVector1.asScratchPisaTimestamp(i), - value2, - i); - } - } - } else { - if (batch.selectedInUse) { - for(int j = 0; j != n; j++) { - int i = sel[j]; - outputColVector.<OperatorMethod>( - inputColVector1.asScratchPisaTimestamp(i), - scratchPisaTimestamp.updateFromTimestampMilliseconds(DateWritable.daysToMillis((int) vector2[i])), - i); - } - } else { - for(int i = 0; i != n; i++) { - outputColVector.<OperatorMethod>( - inputColVector1.asScratchPisaTimestamp(i), - scratchPisaTimestamp.updateFromTimestampMilliseconds(DateWritable.daysToMillis((int) vector2[i])), - i); - } - } - } - - /* 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.setNullDataEntriesTimestamp(outputColVector, batch.selectedInUse, sel, n); - } - - @Override - public int getOutputColumn() { - return outputColumn; - } - - @Override - public String getOutputType() { - return "timestamp"; - } -} - http://git-wip-us.apache.org/repos/asf/hive/blob/52016296/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateScalar.txt ---------------------------------------------------------------------- diff --git a/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateScalar.txt b/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateScalar.txt index b8404db..8b91a4a 100644 --- a/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateScalar.txt +++ b/ql/src/gen/vectorization/ExpressionTemplates/TimestampColumnArithmeticDateScalar.txt @@ -18,7 +18,9 @@ package org.apache.hadoop.hive.ql.exec.vector.expressions.gen; -import org.apache.hadoop.hive.common.type.PisaTimestamp; +import java.sql.Timestamp; + +import org.apache.hadoop.hive.common.type.HiveIntervalDayTime; import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression; import org.apache.hadoop.hive.ql.exec.vector.TimestampColumnVector; import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch; @@ -26,21 +28,107 @@ import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil; import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor; import org.apache.hadoop.hive.ql.exec.vector.*; import org.apache.hadoop.hive.ql.util.DateTimeMath; +import org.apache.hadoop.hive.serde2.io.DateWritable; /** * Generated from template TimestampColumnArithmeticDateScalar.txt, which covers binary arithmetic * expressions between a column and a scalar. */ -public class <ClassName> extends <BaseClassName> { +public class <ClassName> extends VectorExpression { private static final long serialVersionUID = 1L; + private int colNum; + private Timestamp value; + private int outputColumn; + private DateTimeMath dtm = new DateTimeMath(); + public <ClassName>(int colNum, long value, int outputColumn) { - super(colNum, value, outputColumn); + this.colNum = colNum; + this.value = new Timestamp(0); + this.value.setTime(DateWritable.daysToMillis((int) value)); + this.outputColumn = outputColumn; } public <ClassName>() { - super(); + } + + @Override + public void evaluate(VectorizedRowBatch batch) { + + if (childExpressions != null) { + super.evaluateChildren(batch); + } + + // Input #1 is type <OperandType1>. + <InputColumnVectorType1> inputColVector1 = (<InputColumnVectorType1>) batch.cols[colNum]; + + // Output is type <ReturnType>. + <OutputColumnVectorType> outputColVector = (<OutputColumnVectorType>) batch.cols[outputColumn]; + + int[] sel = batch.selected; + boolean[] inputIsNull = inputColVector1.isNull; + boolean[] outputIsNull = outputColVector.isNull; + outputColVector.noNulls = inputColVector1.noNulls; + outputColVector.isRepeating = inputColVector1.isRepeating; + int n = batch.size; + + // return immediately if batch is empty + if (n == 0) { + return; + } + + if (inputColVector1.isRepeating) { + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(0), 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 (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), value, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } else { + for(int i = 0; i != n; i++) { + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), value, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + } + } else /* there are nulls */ { + if (batch.selectedInUse) { + for(int j = 0; j != n; j++) { + int i = sel[j]; + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), value, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + outputIsNull[i] = inputIsNull[i]; + } + } else { + for(int i = 0; i != n; i++) { + dtm.<OperatorMethod>( + inputColVector1.asScratch<CamelOperandType1>(i), value, outputColVector.getScratch<CamelReturnType>()); + outputColVector.setFromScratch<CamelReturnType>(i); + } + System.arraycopy(inputIsNull, 0, outputIsNull, 0, n); + } + } + + NullUtil.setNullOutputEntriesColScalar(outputColVector, batch.selectedInUse, sel, n); + } + + @Override + public int getOutputColumn() { + return outputColumn; + } + + @Override + public String getOutputType() { + return "<ReturnType>"; } @Override @@ -51,7 +139,7 @@ public class <ClassName> extends <BaseClassName> { .setNumArguments(2) .setArgumentTypes( VectorExpressionDescriptor.ArgumentType.getType("<OperandType1>"), - VectorExpressionDescriptor.ArgumentType.getType("<OperandType2>")) + VectorExpressionDescriptor.ArgumentType.getType("date")) .setInputExpressionTypes( VectorExpressionDescriptor.InputExpressionType.COLUMN, VectorExpressionDescriptor.InputExpressionType.SCALAR).build();