ql/src/gen/vectorization/ExpressionTemplates/LongDoubleColumnCompareTimestampColumn.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.sql.Timestamp;
  22
  23 import org.apache.hadoop.hive.ql.exec.vector.expressions.VectorExpression;
  24 import org.apache.hadoop.hive.ql.exec.vector.expressions.NullUtil;
  25 import org.apache.hadoop.hive.ql.exec.vector.*;
  26 import org.apache.hadoop.hive.ql.exec.vector.VectorizedRowBatch;
  27 import org.apache.hadoop.hive.ql.exec.vector.VectorExpressionDescriptor;
  28
  29 /**
  30  * Generated from template ColumnCompareTimestampColumn.txt, which covers binary arithmetic
  31  * expressions between columns.
  32  */
  33 public class <ClassName> extends VectorExpression {
  34
  35   private static final long serialVersionUID = 1L;
  36
  37   private int colNum1;
  38   private int colNum2;
  39   private int outputColumn;
  40
  41   public <ClassName>(int colNum1, int colNum2, int outputColumn) {
  42     this.colNum1 = colNum1;
  43     this.colNum2 = colNum2;
  44     this.outputColumn = outputColumn;
  45   }
  46
  47   public <ClassName>() {
  48   }
  49
  50   @Override
  51   public void evaluate(VectorizedRowBatch batch) {
  52
  53     if (childExpressions != null) {
  54       super.evaluateChildren(batch);
  55     }
  56
  57     <InputColumnVectorType1> inputColVector1 = (<InputColumnVectorType1>) batch.cols[colNum1];
  58     TimestampColumnVector inputColVector2 = (TimestampColumnVector) batch.cols[colNum2];
  59     LongColumnVector outputColVector = (LongColumnVector) batch.cols[outputColumn];
  60     int[] sel = batch.selected;
  61     int n = batch.size;
  62     <OperandType>[] vector1 = inputColVector1.vector;
  63     long[] outputVector = outputColVector.vector;
  64
  65     // return immediately if batch is empty
  66     if (n == 0) {
  67       return;
  68     }
  69
  70     outputColVector.isRepeating =
  71          inputColVector1.isRepeating && inputColVector2.isRepeating
  72       || inputColVector1.isRepeating && !inputColVector1.noNulls && inputColVector1.isNull[0]
  73       || inputColVector2.isRepeating && !inputColVector2.noNulls && inputColVector2.isNull[0];
  74
  75     // Handle nulls first
  76     NullUtil.propagateNullsColCol(
  77       inputColVector1, inputColVector2, outputColVector, sel, n, batch.selectedInUse);
  78
  79     /* Disregard nulls for processing. In other words,
  80      * the arithmetic operation is performed even if one or
  81      * more inputs are null. This is to improve speed by avoiding
  82      * conditional checks in the inner loop.
  83      */
  84     if (inputColVector1.isRepeating && inputColVector2.isRepeating) {
  85       outputVector[0] = vector1[0] <OperatorSymbol> inputColVector2.<GetTimestampLongDoubleMethod>(0) ? 1 : 0;
  86     } else if (inputColVector1.isRepeating) {
  87       if (batch.selectedInUse) {
  88         for(int j = 0; j != n; j++) {
  89           int i = sel[j];
  90           outputVector[i] = vector1[0] <OperatorSymbol> inputColVector2.<GetTimestampLongDoubleMethod>(i) ? 1 : 0;
  91         }
  92       } else {
  93         for(int i = 0; i != n; i++) {
  94           outputVector[i] = vector1[0] <OperatorSymbol> inputColVector2.<GetTimestampLongDoubleMethod>(i) ? 1 : 0;
  95         }
  96       }
  97     } else if (inputColVector2.isRepeating) {
  98       <OperandType> value2 = inputColVector2.<GetTimestampLongDoubleMethod>(0);
  99       if (batch.selectedInUse) {
 100         for(int j = 0; j != n; j++) {
 101           int i = sel[j];
 102           outputVector[i] = vector1[i] <OperatorSymbol> value2 ? 1 : 0;
 103         }
 104       } else {
 105         for(int i = 0; i != n; i++) {
 106           outputVector[i] = vector1[i] <OperatorSymbol> value2 ? 1 : 0;
 107         }
 108       }
 109     } else {
 110       if (batch.selectedInUse) {
 111         for(int j = 0; j != n; j++) {
 112           int i = sel[j];
 113           outputVector[i] = vector1[i] <OperatorSymbol> inputColVector2.<GetTimestampLongDoubleMethod>(i) ? 1 : 0;
 114         }
 115       } else {
 116         for(int i = 0; i != n; i++) {
 117           outputVector[i] = vector1[i] <OperatorSymbol> inputColVector2.<GetTimestampLongDoubleMethod>(i) ? 1 : 0;
 118         }
 119       }
 120     }
 121
 122     /* For the case when the output can have null values, follow
 123      * the convention that the data values must be 1 for long and
 124      * NaN for double. This is to prevent possible later zero-divide errors
 125      * in complex arithmetic expressions like col2 / (col1 - 1)
 126      * in the case when some col1 entries are null.
 127      */
 128     NullUtil.setNullDataEntriesLong(outputColVector, batch.selectedInUse, sel, n);
 129   }
 130
 131   @Override
 132   public int getOutputColumn() {
 133     return outputColumn;
 134   }
 135
 136   @Override
 137   public String getOutputType() {
 138     return "long";
 139   }
 140
 141   @Override
 142   public String vectorExpressionParameters() {
 143     return "col " + colNum1 + ", col " + + colNum2;
 144   }
 145
 146   @Override
 147   public VectorExpressionDescriptor.Descriptor getDescriptor() {
 148     return (new VectorExpressionDescriptor.Builder())
 149         .setMode(
 150             VectorExpressionDescriptor.Mode.PROJECTION)
 151         .setNumArguments(2)
 152         .setArgumentTypes(
 153             VectorExpressionDescriptor.ArgumentType.getType("<OperandType>"),
 154             VectorExpressionDescriptor.ArgumentType.getType("timestamp"))
 155         .setInputExpressionTypes(
 156             VectorExpressionDescriptor.InputExpressionType.COLUMN,
 157             VectorExpressionDescriptor.InputExpressionType.COLUMN).build();
 158   }
 159 }