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