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 }