248a66a5ec2af623aa754d6c4c2823e8264eab4f
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / FilterColumnCompareScalar.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 FilterColumnCompareScalar.txt, which covers binary comparison 
28  * expressions between a column and a scalar, however output is not produced in a separate column. 
29  * The selected vector of the input {@link VectorizedRowBatch} is updated for in-place filtering.
30  */
31 public class <ClassName> extends VectorExpression {
32
33   private static final long serialVersionUID = 1L;
34
35   protected int colNum;
36   protected <OperandType2> value;
37
38   public <ClassName>(int colNum, <OperandType2> value) { 
39     this.colNum = colNum;
40     this.value = value;
41   }
42
43   public <ClassName>() {
44   }
45
46   @Override
47   public void evaluate(VectorizedRowBatch batch) {
48
49     if (childExpressions != null) {
50       super.evaluateChildren(batch);
51     }
52
53     <InputColumnVectorType> inputColVector = (<InputColumnVectorType>) batch.cols[colNum];
54     int[] sel = batch.selected;
55     boolean[] nullPos = inputColVector.isNull;
56     int n = batch.size;
57     <OperandType1>[] vector = inputColVector.vector;
58
59     // return immediately if batch is empty
60     if (n == 0) {
61       return;
62     }
63     
64     if (inputColVector.noNulls) {
65       if (inputColVector.isRepeating) {
66         //All must be selected otherwise size would be zero
67         //Repeating property will not change.
68         if (!(vector[0] <OperatorSymbol> value)) {
69           //Entire batch is filtered out.
70           batch.size = 0;
71         }
72       } else if (batch.selectedInUse) {
73         int newSize = 0;
74         for(int j=0; j != n; j++) {
75           int i = sel[j];
76           if (vector[i] <OperatorSymbol> value) {
77             sel[newSize++] = i;
78           }
79         }
80         batch.size = newSize;
81       } else {
82         int newSize = 0;
83         for(int i = 0; i != n; i++) {
84           if (vector[i] <OperatorSymbol> value) {
85             sel[newSize++] = i;
86           }
87         }
88         if (newSize < n) {
89           batch.size = newSize;
90           batch.selectedInUse = true;
91         }
92       }
93     } else {
94       if (inputColVector.isRepeating) {
95         //All must be selected otherwise size would be zero
96         //Repeating property will not change.
97         if (!nullPos[0]) {
98           if (!(vector[0] <OperatorSymbol> value)) {
99             //Entire batch is filtered out.
100             batch.size = 0;
101           }
102         } else {
103           batch.size = 0;
104         }
105       } else if (batch.selectedInUse) {
106         int newSize = 0;
107         for(int j=0; j != n; j++) {
108           int i = sel[j];
109           if (!nullPos[i]) {
110            if (vector[i] <OperatorSymbol> value) {
111              sel[newSize++] = i;
112            }
113           }
114         }
115         //Change the selected vector
116         batch.size = newSize;
117       } else {
118         int newSize = 0;
119         for(int i = 0; i != n; i++) {
120           if (!nullPos[i]) {
121             if (vector[i] <OperatorSymbol> value) {
122               sel[newSize++] = i;
123             }
124           }
125         }
126         if (newSize < n) {
127           batch.size = newSize;
128           batch.selectedInUse = true;
129         }
130       }
131     }
132   }
133
134   @Override
135   public int getOutputColumn() {
136     return -1;
137   }
138
139   @Override
140   public String getOutputType() {
141     return "boolean";
142   }
143   
144   public int getColNum() {
145     return colNum;
146   }
147
148   public void setColNum(int colNum) {
149     this.colNum = colNum;
150   }
151
152   public <OperandType2> getValue() {
153     return value;
154   }
155
156   public void setValue(<OperandType2> value) {
157     this.value = value;
158   }
159
160   @Override
161   public String vectorExpressionParameters() {
162     return "col " + colNum + ", val " + value;
163   }
164
165   @Override
166   public VectorExpressionDescriptor.Descriptor getDescriptor() {
167     return (new VectorExpressionDescriptor.Builder())
168         .setMode(
169             VectorExpressionDescriptor.Mode.FILTER)
170         .setNumArguments(2)
171         .setArgumentTypes(
172             VectorExpressionDescriptor.ArgumentType.getType("<VectorExprArgType1>"),
173             VectorExpressionDescriptor.ArgumentType.getType("<VectorExprArgType2>"))
174         .setInputExpressionTypes(
175             VectorExpressionDescriptor.InputExpressionType.COLUMN,
176             VectorExpressionDescriptor.InputExpressionType.SCALAR).build();
177   }
178 }