238dc9347cc751183cf5d6721c0360614edb408a
[hive.git] / ql / src / gen / vectorization / ExpressionTemplates / StringGroupScalarCompareStringGroupColumnBase.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.expressions.StringExpr;
23 import org.apache.hadoop.hive.ql.exec.vector.BytesColumnVector;
24 import org.apache.hadoop.hive.ql.exec.vector.LongColumnVector;
25 import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
26 import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
27
28 /**
29  * This is a generated class to evaluate a <OperatorSymbol> comparison on a vector of strings.
30  * Do not edit the generated code directly. 
31  */
32 public abstract class <ClassName> extends VectorExpression {
33
34   private static final long serialVersionUID = 1L;
35
36   protected int colNum;
37   protected byte[] value;
38   protected int outputColumn;
39
40   @Override
41   public void evaluate(VectorizedRowBatch batch) {
42     if (childExpressions != null) {
43       super.evaluateChildren(batch);
44     }
45     BytesColumnVector inputColVector = (BytesColumnVector) batch.cols[colNum];
46     LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumn];
47     int[] sel = batch.selected;
48     boolean[] nullPos = inputColVector.isNull;
49     boolean[] outNull = outputColVector.isNull;
50     int n = batch.size;
51     byte[][] vector = inputColVector.vector;
52     int[] length = inputColVector.length;
53     int[] start = inputColVector.start;
54     long[] outVector = outputColVector.vector; 
55
56     // return immediately if batch is empty
57     if (n == 0) {
58       return;
59     }
60    
61     outputColVector.isRepeating = false;
62     if (inputColVector.noNulls) {
63       outputColVector.noNulls = true;
64       if (inputColVector.isRepeating) {
65         outputColVector.isRepeating = true; 
66         if (<CompareOrEqual>(value, 0, value.length, vector[0], start[0], length[0])<OptionalCompare>) {
67           outVector[0] = 1;
68         } else {
69           outVector[0] = 0;
70         }
71       } else if (batch.selectedInUse) {
72         for(int j=0; j != n; j++) {
73           int i = sel[j];
74           if (<CompareOrEqual>(value, 0, value.length, vector[i], start[i], length[i])<OptionalCompare>) {
75             outVector[i] = 1;
76           } else {
77             outVector[i] = 0;
78           }
79         }
80       } else {
81         for(int i = 0; i != n; i++) {
82           if (<CompareOrEqual>(value, 0, value.length, vector[i], start[i], length[i])<OptionalCompare>) {
83             outVector[i] = 1;
84           } else {
85             outVector[i] = 0;
86           }
87         }
88       }
89     } else {
90       outputColVector.noNulls = false;
91       if (inputColVector.isRepeating) {
92         outputColVector.isRepeating = true;
93         outNull[0] = nullPos[0];
94         if (!nullPos[0]) {
95           if (<CompareOrEqual>(value, 0, value.length, vector[0], start[0], length[0])<OptionalCompare>) {
96             outVector[0] = 1;
97           } else {
98             outVector[0] = 0;
99           }
100         } 
101       } else if (batch.selectedInUse) {
102         for(int j=0; j != n; j++) {
103           int i = sel[j];
104           outNull[i] = nullPos[i];
105           if (!nullPos[i]) {
106             if (<CompareOrEqual>(value, 0, value.length, vector[i], start[i], length[i])<OptionalCompare>) {
107               outVector[i] = 1;
108             } else {
109               outVector[i] = 0;
110             }
111           }
112         }
113       } else {
114         for(int i = 0; i != n; i++) {
115           outNull[i] = nullPos[i];
116           if (!nullPos[i]) {
117             if (<CompareOrEqual>(value, 0, value.length, vector[i], start[i], length[i])<OptionalCompare>) {
118               outVector[i] = 1;
119             } else {
120               outVector[i] = 0;
121             }
122           }
123         }
124       }
125     }
126   }
127
128   @Override
129   public int getOutputColumn() {
130     return outputColumn;
131   }
132
133   @Override
134   public String getOutputType() {
135     return "boolean";
136   }
137   
138   public int getColNum() {
139     return colNum;
140   }
141
142   public void setColNum(int colNum) {
143     this.colNum = colNum;
144   }
145
146   public byte[] getValue() {
147     return value;
148   }
149
150   public void setValue(byte[] value) {
151     this.value = value;
152   }
153
154   public void setOutputColumn(int outputColumn) {
155     this.outputColumn = outputColumn;
156   }
157 }