27e083d587651f6001afd59f9bc215a75e2f0d2d
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / TimestampColumnArithmeticDateColumn.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 TimestampColumnArithmeticDateColumn.txt, which covers binary arithmetic
34  * expressions between columns.
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 scratchTimestamp2;
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     scratchTimestamp2 = 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 <OperandType1>.
64     <InputColumnVectorType1> inputColVector1 = (<InputColumnVectorType1>) batch.cols[colNum1];
65
66     // Input #2 is type date (days).  For the math we convert it to a timestamp.
67     LongColumnVector inputColVector2 = (LongColumnVector) 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
75     long[] vector2 = inputColVector2.vector;
76
77     // return immediately if batch is empty
78     if (n == 0) {
79       return;
80     }
81
82     outputColVector.isRepeating =
83          inputColVector1.isRepeating && inputColVector2.isRepeating
84       || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
85       || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
86
87     // Handle nulls first
88     NullUtil.propagateNullsColCol(
89       inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
90
91     /* Disregard nulls for processing. In other words,
92      * the arithmetic operation is performed even if one or
93      * more inputs are null. This is to improve speed by avoiding
94      * conditional checks in the inner loop.
95      */
96     if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
97       scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[0]));
98       dtm.<OperatorMethod>(
99           inputColVector1.asScratch<CamelOperandType1>(0), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
100       outputColVector.setFromScratch<CamelReturnType>(0);
101     } else if (inputColVector1.isRepeating) {
102       <HiveOperandType1> value1 = inputColVector1.asScratch<CamelOperandType1>(0);
103       if (batch.selectedInUse) {
104         for(int j = 0; j != n; j++) {
105           int i = sel[j];
106           scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i]));
107           dtm.<OperatorMethod>(
108               value1, scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
109           outputColVector.setFromScratch<CamelReturnType>(i);
110         }
111       } else {
112         for(int i = 0; i != n; i++) {
113           scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i]));
114           dtm.<OperatorMethod>(
115               value1, scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
116           outputColVector.setFromScratch<CamelReturnType>(i);
117         }
118       }
119     } else if (inputColVector2.isRepeating) {
120       scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[0]));
121       if (batch.selectedInUse) {
122         for(int j = 0; j != n; j++) {
123           int i = sel[j];
124           dtm.<OperatorMethod>(
125               inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
126           outputColVector.setFromScratch<CamelReturnType>(i);
127         }
128       } else {
129         for(int i = 0; i != n; i++) {
130           dtm.<OperatorMethod>(
131               inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
132           outputColVector.setFromScratch<CamelReturnType>(i);
133         }
134       }
135     } else {
136       if (batch.selectedInUse) {
137         for(int j = 0; j != n; j++) {
138           int i = sel[j];
139           scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i]));
140           dtm.<OperatorMethod>(
141               inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
142           outputColVector.setFromScratch<CamelReturnType>(i);
143         }
144       } else {
145         for(int i = 0; i != n; i++) {
146           scratchTimestamp2.setTime(DateWritable.daysToMillis((int) vector2[i]));
147           dtm.<OperatorMethod>(
148               inputColVector1.asScratch<CamelOperandType1>(i), scratchTimestamp2, outputColVector.getScratch<CamelReturnType>());
149           outputColVector.setFromScratch<CamelReturnType>(i);
150         }
151       }
152     }
153
154     /* For the case when the output can have null values, follow
155      * the convention that the data values must be 1 for long and
156      * NaN for double. This is to prevent possible later zero-divide errors
157      * in complex arithmetic expressions like col2 / (col1 - 1)
158      * in the case when some col1 entries are null.
159      */
160     NullUtil.setNullDataEntries<CamelReturnType>(outputColVector, batch.selectedInUse, sel, n);
161   }
162
163   @Override
164   public int getOutputColumn() {
165     return outputColumn;
166   }
167
168   @Override
169   public String getOutputType() {
170     return "interval_day_time";
171   }
172
173   @Override
174   public VectorExpressionDescriptor.Descriptor getDescriptor() {
175     return (new VectorExpressionDescriptor.Builder())
176         .setMode(
177             VectorExpressionDescriptor.Mode.PROJECTION)
178         .setNumArguments(2)
179         .setArgumentTypes(
180             VectorExpressionDescriptor.ArgumentType.getType("<OperandType1>"),
181             VectorExpressionDescriptor.ArgumentType.getType("date"))
182         .setInputExpressionTypes(
183             VectorExpressionDescriptor.InputExpressionType.COLUMN,
184             VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
185   }
186 }
187