9eba829b0b841dc296f0a5bcf8146dd4e4c6958e
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / IntervalYearMonthColumnArithmeticTimestampColumn.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.HiveIntervalYearMonth;
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
31 /**
32  * Generated from template TimestampColumnArithmeticIntervalYearMonthColumn.txt, which covers binary arithmetic
33  * expressions between columns.
34  */
35 public class <ClassName> extends VectorExpression {
36
37   private static final long serialVersionUID = 1L;
38
39   private int colNum1;
40   private int colNum2;
41   private int outputColumn;
42   private HiveIntervalYearMonth scratchIntervalYearMonth1;
43   private DateTimeMath dtm = new DateTimeMath();
44
45   public <ClassName>(int colNum1, int colNum2, int outputColumn) {
46     this.colNum1 = colNum1;
47     this.colNum2 = colNum2;
48     this.outputColumn = outputColumn;
49     scratchIntervalYearMonth1 = new HiveIntervalYearMonth();
50   }
51
52   public <ClassName>() {
53   }
54
55   @Override
56   public void evaluate(VectorizedRowBatch batch) {
57
58     if (childExpressions != null) {
59       super.evaluateChildren(batch);
60     }
61
62     // Input #1 is type Interval_Year_Month.
63     LongColumnVector inputColVector1 = (LongColumnVector) batch.cols[colNum1];
64
65     // Input #2 is type Timestamp.
66     TimestampColumnVector inputColVector2 = (TimestampColumnVector) batch.cols[colNum2];
67
68     // Output is type Timestamp.
69     TimestampColumnVector outputColVector = (TimestampColumnVector) batch.cols[outputColumn];
70
71     int[] sel = batch.selected;
72     int n = batch.size;
73
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       scratchIntervalYearMonth1.set((int) vector1[0]);
97       dtm.<OperatorMethod>(
98           scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(0), outputColVector.getScratchTimestamp());
99       outputColVector.setFromScratchTimestamp(0);
100     } else if (inputColVector1.isRepeating) {
101       scratchIntervalYearMonth1.set((int) vector1[0]);
102       if (batch.selectedInUse) {
103         for(int j = 0; j != n; j++) {
104           int i = sel[j];
105           dtm.<OperatorMethod>(
106               scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp());
107           outputColVector.setFromScratchTimestamp(i);
108         }
109       } else {
110         for(int i = 0; i != n; i++) {
111           dtm.<OperatorMethod>(
112               scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp());
113           outputColVector.setFromScratchTimestamp(i);
114         }
115       }
116     } else if (inputColVector2.isRepeating) {
117       Timestamp value2 = inputColVector2.asScratchTimestamp(0);
118       if (batch.selectedInUse) {
119         for(int j = 0; j != n; j++) {
120           int i = sel[j];
121           scratchIntervalYearMonth1.set((int) vector1[i]);
122           dtm.<OperatorMethod>(
123               scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp());
124           outputColVector.setFromScratchTimestamp(i);
125         }
126       } else {
127         for(int i = 0; i != n; i++) {
128           scratchIntervalYearMonth1.set((int) vector1[i]);
129           dtm.<OperatorMethod>(
130               scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp());
131           outputColVector.setFromScratchTimestamp(i);
132         }
133       }
134     } else {
135       if (batch.selectedInUse) {
136         for(int j = 0; j != n; j++) {
137           int i = sel[j];
138           scratchIntervalYearMonth1.set((int) vector1[i]);
139           dtm.<OperatorMethod>(
140               scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp());
141           outputColVector.setFromScratchTimestamp(i);
142         }
143       } else {
144         for(int i = 0; i != n; i++) {
145           scratchIntervalYearMonth1.set((int) vector1[i]);
146           dtm.<OperatorMethod>(
147               scratchIntervalYearMonth1, inputColVector2.asScratchTimestamp(i), outputColVector.getScratchTimestamp());
148           outputColVector.setFromScratchTimestamp(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.setNullDataEntriesTimestamp(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 "timestamp";
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("interval_year_month"),
185             VectorExpressionDescriptor.ArgumentType.getType("timestamp"))
186         .setInputExpressionTypes(
187             VectorExpressionDescriptor.InputExpressionType.COLUMN,
188             VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
189   }
190 }
191