0a9c44491b8ca16244256b20f99fed6a27bf66bf
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / FilterColumnBetween.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.<InputColumnVectorType>;
23 import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
24 import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
25
26 /**
27  * Generated from template FilterColumnBetween.txt, which covers [NOT] BETWEEN filter 
28  * expressions where a column is [NOT] between one scalar and another.
29  * Output is not produced in a separate column.  The selected vector of the input 
30  * {@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 colNum;
37   
38   // The comparison is of the form "column BETWEEN leftValue AND rightValue"
39   private <OperandType> leftValue;
40   private <OperandType> rightValue;
41
42   public <ClassName>(int colNum, <OperandType> leftValue, <OperandType> rightValue) { 
43     this.colNum = colNum;
44     this.leftValue = leftValue;
45     this.rightValue = rightValue;
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     <InputColumnVectorType> inputColVector = (<InputColumnVectorType>) batch.cols[colNum];
59     int[] sel = batch.selected;
60     boolean[] nullPos = inputColVector.isNull;
61     int n = batch.size;
62     <OperandType>[] vector = inputColVector.vector;
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.
73         // Repeating property will not change.
74         if (<OptionalNot>(vector[0] < leftValue || vector[0] > rightValue)) {
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>(leftValue <= vector[i] && vector[i] <= rightValue)) {
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 (<OptionalNot>(leftValue <= vector[i] && vector[i] <= rightValue)) {
92             sel[newSize++] = i;
93           }
94         }
95         if (newSize < n) {
96           batch.size = newSize;
97           batch.selectedInUse = true;
98         }
99       }
100     } else {
101       if (inputColVector.isRepeating) {
102       
103         // All must be selected otherwise size would be zero.
104         // Repeating property will not change.
105         if (!nullPos[0]) {
106           if (<OptionalNot>(vector[0] < leftValue || vector[0] > rightValue)) {
107            
108             // Entire batch is filtered out.
109             batch.size = 0;
110           }
111         } else {
112           batch.size = 0;
113         }
114       } else if (batch.selectedInUse) {
115         int newSize = 0;
116         for(int j = 0; j != n; j++) {
117           int i = sel[j];
118           if (!nullPos[i]) {
119            if (<OptionalNot>(leftValue <= vector[i] && vector[i] <= rightValue)) {
120              sel[newSize++] = i;
121            }
122           }
123         }
124         //Change the selected vector
125         batch.size = newSize;
126       } else {
127         int newSize = 0;
128         for(int i = 0; i != n; i++) {
129           if (!nullPos[i]) {
130             if (<OptionalNot>(leftValue <= vector[i] && vector[i] <= rightValue)) {
131               sel[newSize++] = i;
132             }
133           }
134         }
135         if (newSize < n) {
136           batch.size = newSize;
137           batch.selectedInUse = true;
138         }
139       }
140     }
141   }
142
143   @Override
144   public int getOutputColumn() {
145     return -1;
146   }
147
148   @Override
149   public String getOutputType() {
150     return "boolean";
151   }
152   
153   public int getColNum() {
154     return colNum;
155   }
156
157   public void setColNum(int colNum) {
158     this.colNum = colNum;
159   }
160
161   public <OperandType> getLeftValue() {
162     return leftValue;
163   }
164
165   public void setLeftValue(<OperandType> value) {
166     this.leftValue = value;
167   }
168   
169   public <OperandType> getRightValue() {
170     return rightValue;
171   }
172
173   public void setRightValue(<OperandType> value) {
174     this.leftValue = value;
175   }
176
177   @Override
178   public String vectorExpressionParameters() {
179     return "col " + colNum + ", left " + leftValue + ", right " + rightValue;
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("<OperandType>"),
190             VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"),
191             VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"))
192         .setInputExpressionTypes(
193             VectorExpressionDescriptor.InputExpressionType.COLUMN,
194             VectorExpressionDescriptor.InputExpressionType.SCALAR,
195             VectorExpressionDescriptor.InputExpressionType.SCALAR).build();
196   }
197 }