94a174dc18f6b8f71958863176294f3cda9d10cb
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / FilterTruncStringColumnBetween.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.common.type.<TruncStringHiveType>;
22
23 import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
24 import org.apache.hadoop.hive.ql.exec.vector.expressions.StringExpr;
25 import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector;
26 import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
27 import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
28
29
30 /**
31  * This is a generated class to evaluate a [NOT] BETWEEN comparison on a vector of strings.
32  */
33 public class <ClassName> extends VectorExpression {
34
35   private static final long serialVersionUID = 1L;
36
37   private int colNum;
38   private byte[] left;
39   private byte[] right;
40
41   public <ClassName>(int colNum, <TruncStringHiveType> left, <TruncStringHiveType> right) {
42     this.colNum = colNum;
43     this.left = left.<TruncStringHiveGetBytes>;
44     this.right = right.<TruncStringHiveGetBytes>;
45   }
46
47   public <ClassName>() {
48   }
49
50   @Override
51   public void evaluate(VectorizedRowBatch batch) {
52     if (childExpressions != null) {
53       super.evaluateChildren(batch);
54     }
55     BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum];
56     int[] sel = batch.selected;
57     boolean[] nullPos = inputColVector.isNull;
58     int n = batch.size;
59     byte[][] vector = inputColVector.vector;
60     int[] length = inputColVector.length;
61     int[] start = inputColVector.start;
62     
63
64     // return immediately if batch is empty
65     if (n == 0) {
66       return;
67     }
68     
69     if (inputColVector.noNulls) {
70       if (inputColVector.isRepeating) {
71       
72         // All must be selected otherwise size would be zero. Repeating property will not change.
73         if (<OptionalNot>(StringExpr.compare(vector[0], start[0], length[0], left, 0, left.length) < 0
74             || StringExpr.compare(right, 0, right.length, vector[0], start[0], length[0]) < 0)) {
75
76           //Entire batch is filtered out.
77           batch.size = 0;
78         }
79       } else if (batch.selectedInUse) {
80         int newSize = 0;
81         for(int j = 0; j != n; j++) {
82           int i = sel[j];
83           if (<OptionalNot>(StringExpr.compare(left, 0, left.length, vector[i], start[i], length[i]) <= 0
84               && StringExpr.compare(vector[i], start[i], length[i], right, 0, right.length) <= 0)) {
85             sel[newSize++] = i;
86           }
87         }
88         batch.size = newSize;
89       } else {
90         int newSize = 0;
91         for(int i = 0; i != n; i++) {
92           if (<OptionalNot>(StringExpr.compare(left, 0, left.length, vector[i], start[i], length[i]) <= 0
93               && StringExpr.compare(vector[i], start[i], length[i], right, 0, right.length) <= 0)) {
94             sel[newSize++] = i;
95           }
96         }
97         if (newSize < n) {
98           batch.size = newSize;
99           batch.selectedInUse = true;
100         }
101       }
102     } else {
103       if (inputColVector.isRepeating) {
104       
105         // All must be selected otherwise size would be zero. Repeating property will not change.
106         if (!nullPos[0]) {
107           if (<OptionalNot>(StringExpr.compare(vector[0], start[0], length[0], left, 0, left.length) < 0
108             || StringExpr.compare(right, 0, right.length, vector[0], start[0], length[0]) < 0)) {
109
110             //Entire batch is filtered out.
111             batch.size = 0;
112           }
113         } else {
114           batch.size = 0;
115         }
116       } else if (batch.selectedInUse) {
117         int newSize = 0;
118         for(int j=0; j != n; j++) {
119           int i = sel[j];
120           if (!nullPos[i]) {
121            if (<OptionalNot>(StringExpr.compare(left, 0, left.length, vector[i], start[i], length[i]) <= 0
122               && StringExpr.compare(vector[i], start[i], length[i], right, 0, right.length) <= 0)) {
123              sel[newSize++] = i;
124            }
125           }
126         }
127         
128         //Change the selected vector
129         batch.size = newSize;
130       } else {
131         int newSize = 0;
132         for(int i = 0; i != n; i++) {
133           if (!nullPos[i]) {
134             if (<OptionalNot>(StringExpr.compare(left, 0, left.length, vector[i], start[i], length[i]) <= 0
135               && StringExpr.compare(vector[i], start[i], length[i], right, 0, right.length) <= 0)) {
136               sel[newSize++] = i;
137             }
138           }
139         }
140         if (newSize < n) {
141           batch.size = newSize;
142           batch.selectedInUse = true;
143         }
144       }
145     }
146   }
147
148   @Override
149   public int getOutputColumn() {
150     return -1;
151   }
152
153   @Override
154   public String getOutputType() {
155     return "boolean";
156   }
157   
158   public int getColNum() {
159     return colNum;
160   }
161
162   public void setColNum(int colNum) {
163     this.colNum = colNum;
164   }
165
166   public byte[] getLeft() {
167     return left;
168   }
169
170   public void setLeft(byte[] value) {
171     this.left = value;
172   }
173   
174   public byte[] getRight() {
175     return right;
176   }
177
178   public void setRight(byte[] value) {
179     this.right = value;
180   }
181   
182   @Override
183   public VectorExpressionDescriptor.Descriptor getDescriptor() {
184     return (new VectorExpressionDescriptor.Builder())
185         .setMode(
186             VectorExpressionDescriptor.Mode.FILTER)
187         .setNumArguments(3)
188         .setArgumentTypes(
189             VectorExpressionDescriptor.ArgumentType.getType("<TruncStringTypeName>"),
190             VectorExpressionDescriptor.ArgumentType.getType("<TruncStringTypeName>"),
191             VectorExpressionDescriptor.ArgumentType.getType("<TruncStringTypeName>"))
192         .setInputExpressionTypes(
193             VectorExpressionDescriptor.InputExpressionType.COLUMN,
194             VectorExpressionDescriptor.InputExpressionType.SCALAR,
195             VectorExpressionDescriptor.InputExpressionType.SCALAR).build();
196   }
197   
198 }