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