31dce1c2e42ef584dee06dee7f36b80642683b1f
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / FilterTimestampColumnCompareTimestampColumn.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.TimestampColumnVector;
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.serde2.io.HiveDecimalWritable;
30
31 /**
32  * Generated from template FilterTimestampColumnCompareColumn.txt, which covers binary comparison
33  * filter expressions between two columns. Output is not produced in a separate column.
34  * The selected vector of the input {@link VectorizedRowBatch} is updated for in-place filtering.
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
43   public <ClassName>(int colNum1, int colNum2) {
44     this.colNum1 = colNum1;
45     this.colNum2 = colNum2;
46   }
47
48   public <ClassName>() {
49   }
50
51   @Override
52   public void evaluate(VectorizedRowBatch batch) {
53
54     if (childExpressions != null) {
55       super.evaluateChildren(batch);
56     }
57
58      // Input #1 is type <OperandType>.
59     <InputColumnVectorType> inputColVector1 = (<InputColumnVectorType>) batch.cols[colNum1];
60
61      // Input #2 is type <OperandType>.
62     <InputColumnVectorType> inputColVector2 = (<InputColumnVectorType>) batch.cols[colNum2];
63
64     int[] sel = batch.selected;
65     boolean[] nullPos1 = inputColVector1.isNull;
66     boolean[] nullPos2 = inputColVector2.isNull;
67     int n = batch.size;
68
69     // return immediately if batch is empty
70     if (n == 0) {
71       return;
72     }
73
74     // handle case where neither input has nulls
75     if (inputColVector1.noNulls && inputColVector2.noNulls) {
76       if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
77
78         /* Either all must remain selected or all will be eliminated.
79          * Repeating property will not change.
80          */
81         if (!(inputColVector1.compareTo(0, inputColVector2, 0) <OperatorSymbol> 0)) {
82           batch.size = 0;
83         }
84       } else if (inputColVector1.isRepeating) {
85         if (batch.selectedInUse) {
86           int newSize = 0;
87           for(int j = 0; j != n; j++) {
88             int i = sel[j];
89             if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
90               sel[newSize++] = i;
91             }
92           }
93           batch.size = newSize;
94         } else {
95           int newSize = 0;
96           for(int i = 0; i != n; i++) {
97             if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
98               sel[newSize++] = i;
99             }
100           }
101           if (newSize < batch.size) {
102             batch.size = newSize;
103             batch.selectedInUse = true;
104           }
105         }
106       } else if (inputColVector2.isRepeating) {
107         if (batch.selectedInUse) {
108           int newSize = 0;
109           for(int j = 0; j != n; j++) {
110             int i = sel[j];
111             if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
112               sel[newSize++] = i;
113             }
114           }
115           batch.size = newSize;
116         } else {
117           int newSize = 0;
118           for(int i = 0; i != n; i++) {
119             if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
120               sel[newSize++] = i;
121             }
122           }
123           if (newSize < batch.size) {
124             batch.size = newSize;
125             batch.selectedInUse = true;
126           }
127         }
128       } else if (batch.selectedInUse) {
129         int newSize = 0;
130         for(int j = 0; j != n; j++) {
131           int i = sel[j];
132           if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
133             sel[newSize++] = i;
134           }
135         }
136         batch.size = newSize;
137       } else {
138         int newSize = 0;
139         for(int i = 0; i != n; i++) {
140           if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
141             sel[newSize++] = i;
142           }
143         }
144         if (newSize < batch.size) {
145           batch.size = newSize;
146           batch.selectedInUse = true;
147         }
148       }
149
150     // handle case where only input 2 has nulls
151     } else if (inputColVector1.noNulls) {
152       if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
153         if (nullPos2[0] ||
154             !(inputColVector1.compareTo(0, inputColVector2, 0) <OperatorSymbol> 0)) {
155           batch.size = 0;
156         }
157       } else if (inputColVector1.isRepeating) {
158
159          // no need to check for nulls in input 1
160          if (batch.selectedInUse) {
161           int newSize = 0;
162           for(int j = 0; j != n; j++) {
163             int i = sel[j];
164             if (!nullPos2[i]) {
165               if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
166                 sel[newSize++] = i;
167               }
168             }
169           }
170           batch.size = newSize;
171         } else {
172           int newSize = 0;
173           for(int i = 0; i != n; i++) {
174             if (!nullPos2[i]) {
175               if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
176                 sel[newSize++] = i;
177               }
178             }
179           }
180           if (newSize < batch.size) {
181             batch.size = newSize;
182             batch.selectedInUse = true;
183           }
184         }
185       } else if (inputColVector2.isRepeating) {
186         if (nullPos2[0]) {
187
188           // no values will qualify because every comparison will be with NULL
189           batch.size = 0;
190           return;
191         }
192         if (batch.selectedInUse) {
193           int newSize = 0;
194           for(int j = 0; j != n; j++) {
195             int i = sel[j];
196             if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
197               sel[newSize++] = i;
198             }
199           }
200           batch.size = newSize;
201         } else {
202           int newSize = 0;
203           for(int i = 0; i != n; i++) {
204             if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
205               sel[newSize++] = i;
206             }
207           }
208           if (newSize < batch.size) {
209             batch.size = newSize;
210             batch.selectedInUse = true;
211           }
212         }
213       } else { // neither input is repeating
214         if (batch.selectedInUse) {
215           int newSize = 0;
216           for(int j = 0; j != n; j++) {
217             int i = sel[j];
218             if (!nullPos2[i]) {
219               if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
220                 sel[newSize++] = i;
221               }
222             }
223           }
224           batch.size = newSize;
225         } else {
226           int newSize = 0;
227           for(int i = 0; i != n; i++) {
228             if (!nullPos2[i]) {
229               if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
230                 sel[newSize++] = i;
231               }
232             }
233           }
234           if (newSize < batch.size) {
235             batch.size = newSize;
236             batch.selectedInUse = true;
237           }
238         }
239       }
240
241     // handle case where only input 1 has nulls
242     } else if (inputColVector2.noNulls) {
243       if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
244         if (nullPos1[0] ||
245             !(inputColVector1.compareTo(0, inputColVector2, 0) <OperatorSymbol> 0)) {
246           batch.size = 0;
247           return;
248         }
249       } else if (inputColVector1.isRepeating) {
250         if (nullPos1[0]) {
251
252           // if repeating value is null then every comparison will fail so nothing qualifies
253           batch.size = 0;
254           return;
255         }
256         if (batch.selectedInUse) {
257           int newSize = 0;
258           for(int j = 0; j != n; j++) {
259             int i = sel[j];
260             if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
261               sel[newSize++] = i;
262             }
263           }
264           batch.size = newSize;
265         } else {
266           int newSize = 0;
267           for(int i = 0; i != n; i++) {
268             if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
269               sel[newSize++] = i;
270             }
271           }
272           if (newSize < batch.size) {
273             batch.size = newSize;
274             batch.selectedInUse = true;
275           }
276         }
277       } else if (inputColVector2.isRepeating) {
278          if (batch.selectedInUse) {
279           int newSize = 0;
280           for(int j = 0; j != n; j++) {
281             int i = sel[j];
282             if (!nullPos1[i]) {
283               if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
284                 sel[newSize++] = i;
285               }
286             }
287           }
288           batch.size = newSize;
289         } else {
290           int newSize = 0;
291           for(int i = 0; i != n; i++) {
292             if (!nullPos1[i]) {
293               if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
294                 sel[newSize++] = i;
295               }
296             }
297           }
298           if (newSize < batch.size) {
299             batch.size = newSize;
300             batch.selectedInUse = true;
301           }
302         }
303       } else { // neither input is repeating
304          if (batch.selectedInUse) {
305           int newSize = 0;
306           for(int j = 0; j != n; j++) {
307             int i = sel[j];
308             if (!nullPos1[i]) {
309               if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
310                 sel[newSize++] = i;
311               }
312             }
313           }
314           batch.size = newSize;
315         } else {
316           int newSize = 0;
317           for(int i = 0; i != n; i++) {
318             if (!nullPos1[i]) {
319               if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
320                 sel[newSize++] = i;
321               }
322             }
323           }
324           if (newSize < batch.size) {
325             batch.size = newSize;
326             batch.selectedInUse = true;
327           }
328         }
329       }
330
331     // handle case where both inputs have nulls
332     } else {
333       if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
334         if (nullPos1[0] || nullPos2[0] ||
335             !(inputColVector1.compareTo(0, inputColVector2, 0) <OperatorSymbol> 0)) {
336           batch.size = 0;
337         }
338       } else if (inputColVector1.isRepeating) {
339          if (nullPos1[0]) {
340            batch.size = 0;
341            return;
342          }
343          if (batch.selectedInUse) {
344           int newSize = 0;
345           for(int j = 0; j != n; j++) {
346             int i = sel[j];
347             if (!nullPos2[i]) {
348               if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
349                 sel[newSize++] = i;
350               }
351             }
352           }
353           batch.size = newSize;
354         } else {
355           int newSize = 0;
356           for(int i = 0; i != n; i++) {
357             if (!nullPos2[i]) {
358               if (inputColVector1.compareTo(0, inputColVector2, i) <OperatorSymbol> 0) {
359                 sel[newSize++] = i;
360               }
361             }
362           }
363           if (newSize < batch.size) {
364             batch.size = newSize;
365             batch.selectedInUse = true;
366           }
367         }
368       } else if (inputColVector2.isRepeating) {
369         if (nullPos2[0]) {
370           batch.size = 0;
371           return;
372         }
373         if (batch.selectedInUse) {
374           int newSize = 0;
375           for(int j = 0; j != n; j++) {
376             int i = sel[j];
377             if (!nullPos1[i]) {
378               if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
379                 sel[newSize++] = i;
380               }
381             }
382           }
383           batch.size = newSize;
384         } else {
385           int newSize = 0;
386           for(int i = 0; i != n; i++) {
387             if (!nullPos1[i]) {
388               if (inputColVector1.compareTo(i, inputColVector2, 0) <OperatorSymbol> 0) {
389                 sel[newSize++] = i;
390               }
391             }
392           }
393           if (newSize < batch.size) {
394             batch.size = newSize;
395             batch.selectedInUse = true;
396           }
397         }
398       } else { // neither input is repeating
399          if (batch.selectedInUse) {
400           int newSize = 0;
401           for(int j = 0; j != n; j++) {
402             int i = sel[j];
403             if (!nullPos1[i] && !nullPos2[i]) {
404               if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
405                 sel[newSize++] = i;
406               }
407             }
408           }
409           batch.size = newSize;
410         } else {
411           int newSize = 0;
412           for(int i = 0; i != n; i++) {
413             if (!nullPos1[i] && !nullPos2[i]) {
414               if (inputColVector1.compareTo(i, inputColVector2, i) <OperatorSymbol> 0) {
415                 sel[newSize++] = i;
416               }
417             }
418           }
419           if (newSize < batch.size) {
420             batch.size = newSize;
421             batch.selectedInUse = true;
422           }
423         }
424       }
425     }
426   }
427
428   @Override
429   public String getOutputType() {
430     return "boolean";
431   }
432
433   @Override
434   public int getOutputColumn() {
435     return -1;
436   }
437
438   @Override
439   public VectorExpressionDescriptor.Descriptor getDescriptor() {
440     return (new VectorExpressionDescriptor.Builder())
441         .setMode(
442             VectorExpressionDescriptor.Mode.FILTER)
443         .setNumArguments(2)
444         .setArgumentTypes(
445             VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"),
446             VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"))
447         .setInputExpressionTypes(
448             VectorExpressionDescriptor.InputExpressionType.COLUMN,
449             VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
450   }
451 }