2e66b3ac12d18fa7a855e8b1f6e7805b228282dc
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / DateColumnArithmeticTimestampColumn.txt
1 /**
2  * Licensed to the Apache Software Foundation (ASF) under one
3  * or more contributor license agreements.  See the NOTICE file
4  * distributed with this work for additional information
5  * regarding copyright ownership.  The ASF licenses this file
6  * to you under the Apache License, Version 2.0 (the
7  * "License"); you may not use this file except in compliance
8  * with the License.  You may obtain a copy of the License at
9  *
10  *     http://www.apache.org/licenses/LICENSE-2.0
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and
16  * limitations under the License.
17  */
18
19 package org.apache.hadoop.hive.ql.exec.vector.expressions.gen;
20
21 import java.sql.Timestamp;
22
23 import org.apache.hadoop.hive.common.type.HiveIntervalDayTime;
24 import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
25 import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
26 import org.apache.hadoop.hive.ql.exec.vector.*;
27 import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
28 import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
29 import org.apache.hadoop.hive.ql.util.DateTimeMath;
30 import org.apache.hadoop.hive.serde2.io.DateWritable;
31
32 /**
33  * Generated from template DateColumnArithmeticTimestampColumn.txt, a class
34  * which covers binary arithmetic expressions between a date column and timestamp column.
35  */
36 public class <ClassName> extends VectorExpression {
37
38   private static final long serialVersionUID = 1L;
39
40   private int colNum1;
41   private int colNum2;
42   private int outputColumn;
43   private Timestamp scratchTimestamp1;
44   private DateTimeMath dtm = new DateTimeMath();
45
46   public <ClassName>(int colNum1, int colNum2, int outputColumn) {
47     this.colNum1 = colNum1;
48     this.colNum2 = colNum2;
49     this.outputColumn = outputColumn;
50     scratchTimestamp1 = new Timestamp(0);
51   }
52
53   public <ClassName>() {
54   }
55
56   @Override
57   public void evaluate(VectorizedRowBatch batch) {
58
59     if (childExpressions != null) {
60       super.evaluateChildren(batch);
61     }
62
63     // Input #1 is type Date (days).  For the math we convert it to a timestamp.
64     LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1];
65
66     // Input #2 is type <OperandType2>.
67     <InputColumnVectorType2> inputColVector2 = (<InputColumnVectorType2>) batch.cols[colNum2];
68
69     // Output is type <ReturnType>.
70     <OutputColumnVectorType> outputColVector = (<OutputColumnVectorType>) batch.cols[outputColumn];
71
72     int[] sel = batch.selected;
73     int n = batch.size;
74     long[] vector1 = inputColVector1.vector;
75
76     // return immediately if batch is empty
77     if (n == 0) {
78       return;
79     }
80
81     outputColVector.isRepeating =
82          inputColVector1.isRepeating && inputColVector2.isRepeating
83       || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
84       || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
85
86     // Handle nulls first
87     NullUtil.propagateNullsColCol(
88       inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
89
90     /* Disregard nulls for processing. In other words,
91      * the arithmetic operation is performed even if one or
92      * more inputs are null. This is to improve speed by avoiding
93      * conditional checks in the inner loop.
94      */
95     if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
96       scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[0]));
97       dtm.<OperatorMethod>(
98           scratchTimestamp1, inputColVector2.asScratch<CamelOperandType2>(0), outputColVector.getScratch<CamelReturnType>());
99       outputColVector.setFromScratch<CamelReturnType>(0);
100     } else if (inputColVector1.isRepeating) {
101       scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[0]));
102       if (batch.selectedInUse) {
103         for(int j = 0; j != n; j++) {
104           int i = sel[j];
105           dtm.<OperatorMethod>(
106               scratchTimestamp1, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
107           outputColVector.setFromScratch<CamelReturnType>(i);
108         }
109       } else {
110         for(int i = 0; i != n; i++) {
111           dtm.<OperatorMethod>(
112               scratchTimestamp1, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
113           outputColVector.setFromScratch<CamelReturnType>(i);
114         }
115       }
116     } else if (inputColVector2.isRepeating) {
117       <HiveOperandType2> value2 = inputColVector2.asScratch<CamelOperandType2>(0);
118       if (batch.selectedInUse) {
119         for(int j = 0; j != n; j++) {
120           int i = sel[j];
121           scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
122           dtm.<OperatorMethod>(
123               scratchTimestamp1, value2, outputColVector.getScratch<CamelReturnType>());
124           outputColVector.setFromScratch<CamelReturnType>(i);
125          }
126       } else {
127         for(int i = 0; i != n; i++) {
128           scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
129           dtm.<OperatorMethod>(
130               scratchTimestamp1, value2, outputColVector.getScratch<CamelReturnType>());
131           outputColVector.setFromScratch<CamelReturnType>(i);
132         }
133       }
134     } else {
135       if (batch.selectedInUse) {
136         for(int j = 0; j != n; j++) {
137           int i = sel[j];
138           scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
139          dtm.<OperatorMethod>(
140               scratchTimestamp1, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
141           outputColVector.setFromScratch<CamelReturnType>(i);
142         }
143       } else {
144         for(int i = 0; i != n; i++) {
145           scratchTimestamp1.setTime(DateWritable.daysToMillis((int) vector1[i]));
146           dtm.<OperatorMethod>(
147               scratchTimestamp1, inputColVector2.asScratch<CamelOperandType2>(i), outputColVector.getScratch<CamelReturnType>());
148           outputColVector.setFromScratch<CamelReturnType>(i);
149         }
150       }
151     }
152
153     /* For the case when the output can have null values, follow
154      * the convention that the data values must be 1 for long and
155      * NaN for double. This is to prevent possible later zero-divide errors
156      * in complex arithmetic expressions like col2 / (col1 - 1)
157      * in the case when some col1 entries are null.
158      */
159     NullUtil.setNullDataEntries<CamelReturnType>(outputColVector, batch.selectedInUse, sel, n);
160   }
161
162   @Override
163   public int getOutputColumn() {
164     return outputColumn;
165   }
166
167   @Override
168   public String getOutputType() {
169     return "<ReturnType>";
170   }
171
172   @Override
173   public String vectorExpressionParameters() {
174     return "col " + colNum1 + ", col " + + colNum2;
175   }
176
177   @Override
178   public VectorExpressionDescriptor.Descriptor getDescriptor() {
179     return (new VectorExpressionDescriptor.Builder())
180         .setMode(
181             VectorExpressionDescriptor.Mode.PROJECTION)
182         .setNumArguments(2)
183         .setArgumentTypes(
184             VectorExpressionDescriptor.ArgumentType.getType("date"),
185             VectorExpressionDescriptor.ArgumentType.getType("<OperandType2>"))
186         .setInputExpressionTypes(
187             VectorExpressionDescriptor.InputExpressionType.COLUMN,
188             VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
189   }
190 }
191