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