hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mmccl...@apache.org
Subject [14/15] hive git commit: HIVE-9862 Vectorized execution corrupts timestamp values (Matt McCline, reviewed by Jason Dere)
Date Tue, 09 Feb 2016 19:16:15 GMT
http://git-wip-us.apache.org/repos/asf/hive/blob/a11a6ca6/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java
----------------------------------------------------------------------
diff --git a/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java b/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java
index 6c57da2..2e369ec 100644
--- a/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java
+++ b/ant/src/org/apache/hadoop/hive/ant/GenVectorCode.java
@@ -35,7 +35,40 @@ public class GenVectorCode extends Task {
 
   private static String [][] templateExpansions =
     {
-      // The following datetime/interval arithmetic operations can be done using the vectorized values
+
+      /**
+       * date is stored in a LongColumnVector as epochDays
+       * interval_year_month is stored in a LongColumnVector as epochMonths
+       *
+       * interval_day_time and timestamp are stored in a TimestampColumnVector (2 longs to hold
+       *     very large number of nanoseconds)
+       *
+       * date – date --> type: interval_day_time
+       * timestamp – date --> type: interval_day_time
+       * date – timestamp --> type: interval_day_time
+       * timestamp – timestamp --> type: interval_day_time
+       *
+       * date +|- interval_day_time --> type: timestamp
+       * interval_day_time + date --> type: timestamp
+       *
+       * timestamp +|- interval_day_time --> type: timestamp
+       * interval_day_time +|- timestamp --> type: timestamp
+       *
+       * date +|- interval_year_month --> type: date
+       * interval_year_month + date --> type: date
+       *
+       * timestamp +|- interval_year_month --> type: timestamp
+       * interval_year_month + timestamp --> type: timestamp
+       *
+       * Adding/Subtracting months done with Calendar object
+       *
+       * Timestamp Compare with Long with long interpreted as seconds
+       * Timestamp Compare with Double with double interpreted as seconds with fractional nanoseconds
+       *
+       */
+
+      // The following datetime/interval arithmetic operations can be done using the vectorized values.
+      // Type interval_year_month (LongColumnVector storing months).
       {"DTIColumnArithmeticDTIScalarNoConvert", "Add", "interval_year_month", "interval_year_month", "+"},
       {"DTIScalarArithmeticDTIColumnNoConvert", "Add", "interval_year_month", "interval_year_month", "+"},
       {"DTIColumnArithmeticDTIColumnNoConvert", "Add", "interval_year_month", "interval_year_month", "+"},
@@ -44,80 +77,114 @@ public class GenVectorCode extends Task {
       {"DTIScalarArithmeticDTIColumnNoConvert", "Subtract", "interval_year_month", "interval_year_month", "-"},
       {"DTIColumnArithmeticDTIColumnNoConvert", "Subtract", "interval_year_month", "interval_year_month", "-"},
 
-      {"DTIColumnArithmeticDTIScalarNoConvert", "Add", "interval_day_time", "interval_day_time", "+"},
-      {"DTIScalarArithmeticDTIColumnNoConvert", "Add", "interval_day_time", "interval_day_time", "+"},
-      {"DTIColumnArithmeticDTIColumnNoConvert", "Add", "interval_day_time", "interval_day_time", "+"},
-
-      {"DTIColumnArithmeticDTIScalarNoConvert", "Subtract", "interval_day_time", "interval_day_time", "-"},
-      {"DTIScalarArithmeticDTIColumnNoConvert", "Subtract", "interval_day_time", "interval_day_time", "-"},
-      {"DTIColumnArithmeticDTIColumnNoConvert", "Subtract", "interval_day_time", "interval_day_time", "-"},
-
-      {"DTIColumnArithmeticDTIScalarNoConvert", "Add", "interval_day_time", "timestamp", "+"},
-      {"DTIScalarArithmeticDTIColumnNoConvert", "Add", "interval_day_time", "timestamp", "+"},
-      {"DTIColumnArithmeticDTIColumnNoConvert", "Add", "interval_day_time", "timestamp", "+"},
-
-      {"DTIColumnArithmeticDTIScalarNoConvert", "Add", "timestamp", "interval_day_time", "+"},
-      {"DTIScalarArithmeticDTIColumnNoConvert", "Add", "timestamp", "interval_day_time", "+"},
-      {"DTIColumnArithmeticDTIColumnNoConvert", "Add", "timestamp", "interval_day_time", "+"},
-
-      {"DTIColumnArithmeticDTIScalarNoConvert", "Subtract", "timestamp", "interval_day_time", "-"},
-      {"DTIScalarArithmeticDTIColumnNoConvert", "Subtract", "timestamp", "interval_day_time", "-"},
-      {"DTIColumnArithmeticDTIColumnNoConvert", "Subtract", "timestamp", "interval_day_time", "-"},
-
-      {"DTIColumnArithmeticDTIScalarNoConvert", "Subtract", "timestamp", "timestamp", "-"},
-      {"DTIScalarArithmeticDTIColumnNoConvert", "Subtract", "timestamp", "timestamp", "-"},
-      {"DTIColumnArithmeticDTIColumnNoConvert", "Subtract", "timestamp", "timestamp", "-"},
-
-      // The following datetime/interval arithmetic functions require type conversion for one or both operands
-      {"ColumnArithmeticColumnWithConvert", "Subtract", "date", "date", "-", "TimestampUtils.daysToNanoseconds", "TimestampUtils.daysToNanoseconds"},
-      {"ScalarArithmeticColumnWithConvert", "Subtract", "date", "date", "-", "TimestampUtils.daysToNanoseconds", "TimestampUtils.daysToNanoseconds"},
-      {"ColumnArithmeticScalarWithConvert", "Subtract", "date", "date", "-", "TimestampUtils.daysToNanoseconds", "TimestampUtils.daysToNanoseconds"},
-
-      {"ColumnArithmeticColumnWithConvert", "Subtract", "date", "timestamp", "-", "TimestampUtils.daysToNanoseconds", ""},
-      {"ScalarArithmeticColumnWithConvert", "Subtract", "date", "timestamp", "-", "TimestampUtils.daysToNanoseconds", ""},
-      {"ColumnArithmeticScalarWithConvert", "Subtract", "date", "timestamp", "-", "TimestampUtils.daysToNanoseconds", ""},
-
-      {"ColumnArithmeticColumnWithConvert", "Subtract", "timestamp", "date", "-", "", "TimestampUtils.daysToNanoseconds"},
-      {"ScalarArithmeticColumnWithConvert", "Subtract", "timestamp", "date", "-", "", "TimestampUtils.daysToNanoseconds"},
-      {"ColumnArithmeticScalarWithConvert", "Subtract", "timestamp", "date", "-", "", "TimestampUtils.daysToNanoseconds"},
-
-      {"ColumnArithmeticColumnWithConvert", "Add", "date", "interval_day_time", "+", "TimestampUtils.daysToNanoseconds", ""},
-      {"ScalarArithmeticColumnWithConvert", "Add", "date", "interval_day_time", "+", "TimestampUtils.daysToNanoseconds", ""},
-      {"ColumnArithmeticScalarWithConvert", "Add", "date", "interval_day_time", "+", "TimestampUtils.daysToNanoseconds", ""},
-
-      {"ColumnArithmeticColumnWithConvert", "Subtract", "date", "interval_day_time", "-", "TimestampUtils.daysToNanoseconds", ""},
-      {"ScalarArithmeticColumnWithConvert", "Subtract", "date", "interval_day_time", "-", "TimestampUtils.daysToNanoseconds", ""},
-      {"ColumnArithmeticScalarWithConvert", "Subtract", "date", "interval_day_time", "-", "TimestampUtils.daysToNanoseconds", ""},
-
-      {"ColumnArithmeticColumnWithConvert", "Add", "interval_day_time", "date", "+", "", "TimestampUtils.daysToNanoseconds"},
-      {"ScalarArithmeticColumnWithConvert", "Add", "interval_day_time", "date", "+", "", "TimestampUtils.daysToNanoseconds"},
-      {"ColumnArithmeticScalarWithConvert", "Add", "interval_day_time", "date", "+", "", "TimestampUtils.daysToNanoseconds"},
-
-      // Most year-month interval arithmetic needs its own generation
-      {"DateTimeColumnArithmeticIntervalColumnWithConvert", "Add", "date", "interval_year_month", "+", "", "dtm.addMonthsToDays"},
-      {"DateTimeScalarArithmeticIntervalColumnWithConvert", "Add", "date", "interval_year_month", "+", "", "dtm.addMonthsToDays"},
-      {"DateTimeColumnArithmeticIntervalScalarWithConvert", "Add", "date", "interval_year_month", "+", "", "dtm.addMonthsToDays"},
-
-      {"DateTimeColumnArithmeticIntervalColumnWithConvert", "Subtract", "date", "interval_year_month", "-", "", "dtm.addMonthsToDays"},
-      {"DateTimeScalarArithmeticIntervalColumnWithConvert", "Subtract", "date", "interval_year_month", "-", "", "dtm.addMonthsToDays"},
-      {"DateTimeColumnArithmeticIntervalScalarWithConvert", "Subtract", "date", "interval_year_month", "-", "", "dtm.addMonthsToDays"},
-
-      {"DateTimeColumnArithmeticIntervalColumnWithConvert", "Add", "timestamp", "interval_year_month", "+", "", "dtm.addMonthsToNanosUtc"},
-      {"DateTimeScalarArithmeticIntervalColumnWithConvert", "Add", "timestamp", "interval_year_month", "+", "", "dtm.addMonthsToNanosUtc"},
-      {"DateTimeColumnArithmeticIntervalScalarWithConvert", "Add", "timestamp", "interval_year_month", "+", "", "dtm.addMonthsToNanosUtc"},
-
-      {"DateTimeColumnArithmeticIntervalColumnWithConvert", "Subtract", "timestamp", "interval_year_month", "-", "", "dtm.addMonthsToNanosUtc"},
-      {"DateTimeScalarArithmeticIntervalColumnWithConvert", "Subtract", "timestamp", "interval_year_month", "-", "", "dtm.addMonthsToNanosUtc"},
-      {"DateTimeColumnArithmeticIntervalScalarWithConvert", "Subtract", "timestamp", "interval_year_month", "-", "", "dtm.addMonthsToNanosUtc"},
-
-      {"IntervalColumnArithmeticDateTimeColumnWithConvert", "Add", "interval_year_month", "date", "+", "", "dtm.addMonthsToDays"},
-      {"IntervalScalarArithmeticDateTimeColumnWithConvert", "Add", "interval_year_month", "date", "+", "", "dtm.addMonthsToDays"},
-      {"IntervalColumnArithmeticDateTimeScalarWithConvert", "Add", "interval_year_month", "date", "+", "", "dtm.addMonthsToDays"},
-
-      {"IntervalColumnArithmeticDateTimeColumnWithConvert", "Add", "interval_year_month", "timestamp", "+", "", "dtm.addMonthsToNanosUtc"},
-      {"IntervalScalarArithmeticDateTimeColumnWithConvert", "Add", "interval_year_month", "timestamp", "+", "", "dtm.addMonthsToNanosUtc"},
-      {"IntervalColumnArithmeticDateTimeScalarWithConvert", "Add", "interval_year_month", "timestamp", "+", "", "dtm.addMonthsToNanosUtc"},
-
+      // Arithmetic on two TimestampColumnVector base classes.
+      {"TimestampArithmeticTimestampBase", "Add", "Col", "Column"},
+      {"TimestampArithmeticTimestampBase", "Add", "Scalar", "Column"},
+      {"TimestampArithmeticTimestampBase", "Add", "Col", "Scalar"},
+
+      {"TimestampArithmeticTimestampBase", "Subtract", "Col", "Column"},
+      {"TimestampArithmeticTimestampBase", "Subtract", "Scalar", "Column"},
+      {"TimestampArithmeticTimestampBase", "Subtract", "Col", "Scalar"},
+
+      // Arithmetic on two type interval_day_time (TimestampColumnVector storing nanosecond interval
+      // in 2 longs) produces a interval_day_time.
+      {"TimestampArithmeticTimestamp", "Add", "interval_day_time", "Col", "interval_day_time", "Scalar"},
+      {"TimestampArithmeticTimestamp", "Add", "interval_day_time", "Scalar", "interval_day_time", "Column"},
+      {"TimestampArithmeticTimestamp", "Add", "interval_day_time", "Col", "interval_day_time", "Column"},
+
+      {"TimestampArithmeticTimestamp", "Subtract", "interval_day_time", "Col", "interval_day_time", "Scalar"},
+      {"TimestampArithmeticTimestamp", "Subtract", "interval_day_time", "Scalar", "interval_day_time", "Column"},
+      {"TimestampArithmeticTimestamp", "Subtract", "interval_day_time", "Col", "interval_day_time", "Column"},
+
+      // A type timestamp (TimestampColumnVector) plus/minus a type interval_day_time (TimestampColumnVector
+      // storing nanosecond interval in 2 longs) produces a timestamp.
+      {"TimestampArithmeticTimestamp", "Add", "interval_day_time", "Col", "timestamp", "Scalar"},
+      {"TimestampArithmeticTimestamp", "Add", "interval_day_time", "Scalar", "timestamp", "Column"},
+      {"TimestampArithmeticTimestamp", "Add", "interval_day_time", "Col", "timestamp", "Column"},
+
+      {"TimestampArithmeticTimestamp", "Add", "timestamp", "Col", "interval_day_time", "Scalar"},
+      {"TimestampArithmeticTimestamp", "Add", "timestamp", "Scalar", "interval_day_time", "Column"},
+      {"TimestampArithmeticTimestamp", "Add", "timestamp", "Col", "interval_day_time", "Column"},
+
+      {"TimestampArithmeticTimestamp", "Subtract", "timestamp", "Col", "interval_day_time", "Scalar"},
+      {"TimestampArithmeticTimestamp", "Subtract", "timestamp", "Scalar", "interval_day_time", "Column"},
+      {"TimestampArithmeticTimestamp", "Subtract", "timestamp", "Col", "interval_day_time", "Column"},
+
+      // A type timestamp (TimestampColumnVector) minus a type timestamp produces a
+      // type interval_day_time (TimestampColumnVector storing nanosecond interval in 2 longs).
+      {"TimestampArithmeticTimestamp", "Subtract", "timestamp", "Col", "timestamp", "Scalar"},
+      {"TimestampArithmeticTimestamp", "Subtract", "timestamp", "Scalar", "timestamp", "Column"},
+      {"TimestampArithmeticTimestamp", "Subtract", "timestamp", "Col", "timestamp", "Column"},
+
+      // Arithmetic on a TimestampColumnVector and date base classes.
+      {"DateArithmeticTimestampBase", "Add", "Col", "Column"},
+      {"DateArithmeticTimestampBase", "Add", "Scalar", "Column"},
+      {"DateArithmeticTimestampBase", "Add", "Col", "Scalar"},
+
+      {"DateArithmeticTimestampBase", "Subtract", "Col", "Column"},
+      {"DateArithmeticTimestampBase", "Subtract", "Scalar", "Column"},
+      {"DateArithmeticTimestampBase", "Subtract", "Col", "Scalar"},
+
+      {"TimestampArithmeticDateBase", "Add", "Col", "Column"},
+      {"TimestampArithmeticDateBase", "Add", "Scalar", "Column"},
+      {"TimestampArithmeticDateBase", "Add", "Col", "Scalar"},
+
+      {"TimestampArithmeticDateBase", "Subtract", "Col", "Column"},
+      {"TimestampArithmeticDateBase", "Subtract", "Scalar", "Column"},
+      {"TimestampArithmeticDateBase", "Subtract", "Col", "Scalar"},
+
+      // Arithmetic with a type date (LongColumnVector storing epoch days) and type interval_day_time (TimestampColumnVector storing
+      // nanosecond interval in 2 longs) produces a type timestamp (TimestampColumnVector).
+      {"DateArithmeticTimestamp", "Add", "date", "Col", "interval_day_time", "Column"},
+      {"DateArithmeticTimestamp", "Add", "date", "Scalar", "interval_day_time", "Column"},
+      {"DateArithmeticTimestamp", "Add", "date", "Col", "interval_day_time", "Scalar"},
+
+      {"DateArithmeticTimestamp", "Subtract", "date", "Col", "interval_day_time", "Column"},
+      {"DateArithmeticTimestamp", "Subtract", "date", "Scalar", "interval_day_time", "Column"},
+      {"DateArithmeticTimestamp", "Subtract", "date", "Col", "interval_day_time", "Scalar"},
+
+      {"TimestampArithmeticDate", "Add", "interval_day_time", "Col", "date", "Column"},
+      {"TimestampArithmeticDate", "Add", "interval_day_time", "Scalar", "date", "Column"},
+      {"TimestampArithmeticDate", "Add", "interval_day_time", "Col", "date", "Scalar"},
+
+      // Subtraction with a type date (LongColumnVector storing epoch days) and type timestamp produces a type timestamp (TimestampColumnVector).
+      {"DateArithmeticTimestamp", "Subtract", "date", "Col", "timestamp", "Column"},
+      {"DateArithmeticTimestamp", "Subtract", "date", "Scalar", "timestamp", "Column"},
+      {"DateArithmeticTimestamp", "Subtract", "date", "Col", "timestamp", "Scalar"},
+
+      {"TimestampArithmeticDate", "Subtract", "timestamp", "Col", "date", "Column"},
+      {"TimestampArithmeticDate", "Subtract", "timestamp", "Scalar", "date", "Column"},
+      {"TimestampArithmeticDate", "Subtract", "timestamp", "Col", "date", "Scalar"},
+
+      // Arithmetic with a type date (LongColumnVector storing epoch days) and type interval_year_month (LongColumnVector storing
+      // months) produces a type date via a calendar calculation.
+      {"DateArithmeticIntervalYearMonth", "Add", "+", "date", "Col", "interval_year_month", "Column"},
+      {"DateArithmeticIntervalYearMonth", "Add", "+", "date", "Scalar", "interval_year_month", "Column"},
+      {"DateArithmeticIntervalYearMonth", "Add", "+", "date", "Col", "interval_year_month", "Scalar"},
+
+      {"DateArithmeticIntervalYearMonth", "Subtract", "-", "date", "Col", "interval_year_month", "Column"},
+      {"DateArithmeticIntervalYearMonth", "Subtract", "-", "date", "Scalar", "interval_year_month", "Column"},
+      {"DateArithmeticIntervalYearMonth", "Subtract", "-", "date", "Col", "interval_year_month", "Scalar"},
+
+      {"IntervalYearMonthArithmeticDate", "Add", "+", "interval_year_month", "Col", "date", "Column"},
+      {"IntervalYearMonthArithmeticDate", "Add", "+", "interval_year_month", "Scalar", "date", "Column"},
+      {"IntervalYearMonthArithmeticDate", "Add", "+", "interval_year_month", "Col", "date", "Scalar"},
+
+      // Arithmetic with a type timestamp (TimestampColumnVector) and type interval_year_month (LongColumnVector storing
+      // months) produces a type timestamp via a calendar calculation.
+      {"TimestampArithmeticIntervalYearMonth", "Add", "+", "timestamp", "Col", "interval_year_month", "Column"},
+      {"TimestampArithmeticIntervalYearMonth", "Add", "+", "timestamp", "Scalar", "interval_year_month", "Column"},
+      {"TimestampArithmeticIntervalYearMonth", "Add", "+", "timestamp", "Col", "interval_year_month", "Scalar"},
+
+      {"TimestampArithmeticIntervalYearMonth", "Subtract", "-", "timestamp", "Col", "interval_year_month", "Column"},
+      {"TimestampArithmeticIntervalYearMonth", "Subtract", "-", "timestamp", "Scalar", "interval_year_month", "Column"},
+      {"TimestampArithmeticIntervalYearMonth", "Subtract", "-", "timestamp", "Col", "interval_year_month", "Scalar"},
+
+      {"IntervalYearMonthArithmeticTimestamp", "Add","+", "interval_year_month", "Col", "timestamp", "Column"},
+      {"IntervalYearMonthArithmeticTimestamp", "Add","+", "interval_year_month", "Scalar", "timestamp", "Column"},
+      {"IntervalYearMonthArithmeticTimestamp", "Add","+", "interval_year_month", "Col", "timestamp", "Scalar"},
+
+      // Long/double arithmetic
       {"ColumnArithmeticScalar", "Add", "long", "long", "+"},
       {"ColumnArithmeticScalar", "Subtract", "long", "long", "-"},
       {"ColumnArithmeticScalar", "Multiply", "long", "long", "*"},
@@ -251,46 +318,151 @@ public class GenVectorCode extends Task {
       {"ScalarCompareColumn", "Greater", "double", "long", ">"},
       {"ScalarCompareColumn", "GreaterEqual", "double", "long", ">="},
 
-      {"TimestampColumnCompareTimestampScalar", "Equal"},
-      {"TimestampColumnCompareTimestampScalar", "NotEqual"},
-      {"TimestampColumnCompareTimestampScalar", "Less"},
-      {"TimestampColumnCompareTimestampScalar", "LessEqual"},
-      {"TimestampColumnCompareTimestampScalar", "Greater"},
-      {"TimestampColumnCompareTimestampScalar", "GreaterEqual"},
-
-      {"TimestampColumnCompareScalar", "Equal", "long"},
-      {"TimestampColumnCompareScalar", "Equal", "double"},
-      {"TimestampColumnCompareScalar", "NotEqual", "long"},
-      {"TimestampColumnCompareScalar", "NotEqual", "double"},
-      {"TimestampColumnCompareScalar", "Less", "long"},
-      {"TimestampColumnCompareScalar", "Less", "double"},
-      {"TimestampColumnCompareScalar", "LessEqual", "long"},
-      {"TimestampColumnCompareScalar", "LessEqual", "double"},
-      {"TimestampColumnCompareScalar", "Greater", "long"},
-      {"TimestampColumnCompareScalar", "Greater", "double"},
-      {"TimestampColumnCompareScalar", "GreaterEqual", "long"},
-      {"TimestampColumnCompareScalar", "GreaterEqual", "double"},
-
-      {"TimestampScalarCompareTimestampColumn", "Equal"},
-      {"TimestampScalarCompareTimestampColumn", "NotEqual"},
-      {"TimestampScalarCompareTimestampColumn", "Less"},
-      {"TimestampScalarCompareTimestampColumn", "LessEqual"},
-      {"TimestampScalarCompareTimestampColumn", "Greater"},
-      {"TimestampScalarCompareTimestampColumn", "GreaterEqual"},
-
-      {"ScalarCompareTimestampColumn", "Equal", "long"},
-      {"ScalarCompareTimestampColumn", "Equal", "double"},
-      {"ScalarCompareTimestampColumn", "NotEqual", "long"},
-      {"ScalarCompareTimestampColumn", "NotEqual", "double"},
-      {"ScalarCompareTimestampColumn", "Less", "long"},
-      {"ScalarCompareTimestampColumn", "Less", "double"},
-      {"ScalarCompareTimestampColumn", "LessEqual", "long"},
-      {"ScalarCompareTimestampColumn", "LessEqual", "double"},
-      {"ScalarCompareTimestampColumn", "Greater", "long"},
-      {"ScalarCompareTimestampColumn", "Greater", "double"},
-      {"ScalarCompareTimestampColumn", "GreaterEqual", "long"},
-      {"ScalarCompareTimestampColumn", "GreaterEqual", "double"},
-
+      // Base compare timestamp to timestamp used by Timestamp and IntervalDayTime.
+      {"TimestampCompareTimestampBase", "Equal", "==", "Col", "Column"},
+      {"TimestampCompareTimestampBase", "NotEqual", "!=", "Col", "Column"},
+      {"TimestampCompareTimestampBase", "Less", "<", "Col", "Column"},
+      {"TimestampCompareTimestampBase", "LessEqual", "<=", "Col", "Column"},
+      {"TimestampCompareTimestampBase", "Greater", ">", "Col", "Column"},
+      {"TimestampCompareTimestampBase", "GreaterEqual", ">=", "Col", "Column"},
+
+      {"TimestampCompareTimestampBase", "Equal", "==", "Col", "Scalar"},
+      {"TimestampCompareTimestampBase", "NotEqual", "!=", "Col", "Scalar"},
+      {"TimestampCompareTimestampBase", "Less", "<", "Col", "Scalar"},
+      {"TimestampCompareTimestampBase", "LessEqual", "<=", "Col", "Scalar"},
+      {"TimestampCompareTimestampBase", "Greater", ">", "Col", "Scalar"},
+      {"TimestampCompareTimestampBase", "GreaterEqual", ">=", "Col", "Scalar"},
+
+      {"TimestampCompareTimestampBase", "Equal", "==", "Scalar", "Column"},
+      {"TimestampCompareTimestampBase", "NotEqual", "!=", "Scalar", "Column"},
+      {"TimestampCompareTimestampBase", "Less", "<", "Scalar", "Column"},
+      {"TimestampCompareTimestampBase", "LessEqual", "<=", "Scalar", "Column"},
+      {"TimestampCompareTimestampBase", "Greater", ">", "Scalar", "Column"},
+      {"TimestampCompareTimestampBase", "GreaterEqual", ">=", "Scalar", "Column"},
+
+      // Compare timestamp to timestamp.
+      {"TimestampCompareTimestamp", "Equal", "timestamp", "Col", "Column"},
+      {"TimestampCompareTimestamp", "NotEqual", "timestamp", "Col", "Column"},
+      {"TimestampCompareTimestamp", "Less", "timestamp", "Col", "Column"},
+      {"TimestampCompareTimestamp", "LessEqual", "timestamp", "Col", "Column"},
+      {"TimestampCompareTimestamp", "Greater", "timestamp", "Col", "Column"},
+      {"TimestampCompareTimestamp", "GreaterEqual", "timestamp", "Col", "Column"},
+
+      {"TimestampCompareTimestamp", "Equal", "timestamp", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "NotEqual", "timestamp", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "Less", "timestamp", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "LessEqual", "timestamp", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "Greater", "timestamp", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "GreaterEqual", "timestamp", "Col", "Scalar"},
+
+      {"TimestampCompareTimestamp", "Equal", "timestamp", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "NotEqual", "timestamp", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "Less", "timestamp", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "LessEqual", "timestamp", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "Greater", "timestamp", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "GreaterEqual", "timestamp", "Scalar", "Column"},
+
+      {"TimestampCompareTimestamp", "Equal", "interval_day_time", "Col", "Column"},
+      {"TimestampCompareTimestamp", "NotEqual", "interval_day_time", "Col", "Column"},
+      {"TimestampCompareTimestamp", "Less", "interval_day_time", "Col", "Column"},
+      {"TimestampCompareTimestamp", "LessEqual", "interval_day_time", "Col", "Column"},
+      {"TimestampCompareTimestamp", "Greater", "interval_day_time", "Col", "Column"},
+      {"TimestampCompareTimestamp", "GreaterEqual", "interval_day_time", "Col", "Column"},
+
+      {"TimestampCompareTimestamp", "Equal", "interval_day_time", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "NotEqual", "interval_day_time", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "Less", "interval_day_time", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "LessEqual", "interval_day_time", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "Greater", "interval_day_time", "Col", "Scalar"},
+      {"TimestampCompareTimestamp", "GreaterEqual", "interval_day_time", "Col", "Scalar"},
+
+      {"TimestampCompareTimestamp", "Equal", "interval_day_time", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "NotEqual", "interval_day_time", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "Less", "interval_day_time", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "LessEqual", "interval_day_time", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "Greater", "interval_day_time", "Scalar", "Column"},
+      {"TimestampCompareTimestamp", "GreaterEqual", "interval_day_time", "Scalar", "Column"},
+
+      // Compare timestamp to integer seconds or double seconds with fractional nanoseonds.
+      {"TimestampCompareLongDouble", "Equal", "long", "==", "Col", "Column"},
+      {"TimestampCompareLongDouble", "Equal", "double", "==", "Col", "Column"},
+      {"TimestampCompareLongDouble", "NotEqual", "long", "!=", "Col", "Column"},
+      {"TimestampCompareLongDouble", "NotEqual", "double", "!=", "Col", "Column"},
+      {"TimestampCompareLongDouble", "Less", "long", "<", "Col", "Column"},
+      {"TimestampCompareLongDouble", "Less", "double", "<", "Col", "Column"},
+      {"TimestampCompareLongDouble", "LessEqual", "long", "<=", "Col", "Column"},
+      {"TimestampCompareLongDouble", "LessEqual", "double", "<=", "Col", "Column"},
+      {"TimestampCompareLongDouble", "Greater", "long", ">", "Col", "Column"},
+      {"TimestampCompareLongDouble", "Greater", "double", ">", "Col", "Column"},
+      {"TimestampCompareLongDouble", "GreaterEqual", "long", ">=", "Col", "Column"},
+      {"TimestampCompareLongDouble", "GreaterEqual", "double", ">=", "Col", "Column"},
+
+      {"LongDoubleCompareTimestamp", "Equal", "long", "==", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "Equal", "double", "==", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "NotEqual", "long", "!=", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "NotEqual", "double", "!=", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "Less", "long", "<", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "Less", "double", "<", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "LessEqual", "long", "<=", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "LessEqual", "double", "<=", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "Greater", "long", ">", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "Greater", "double", ">", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "GreaterEqual", "long", ">=", "Col", "Column"},
+      {"LongDoubleCompareTimestamp", "GreaterEqual", "double", ">=", "Col", "Column"},
+
+      {"TimestampCompareLongDouble", "Equal", "long", "==", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "Equal", "double", "==", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "NotEqual", "long", "!=", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "NotEqual", "double", "!=", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "Less", "long", "<", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "Less", "double", "<", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "LessEqual", "long", "<=", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "LessEqual", "double", "<=", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "Greater", "long", ">", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "Greater", "double", ">", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "GreaterEqual", "long", ">=", "Col", "Scalar"},
+      {"TimestampCompareLongDouble", "GreaterEqual", "double", ">=", "Col", "Scalar"},
+
+      {"LongDoubleCompareTimestamp", "Equal", "long", "==", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "Equal", "double", "==", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "NotEqual", "long", "!=", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "NotEqual", "double", "!=", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "Less", "long", "<", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "Less", "double", "<", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "LessEqual", "long", "<=", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "LessEqual", "double", "<=", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "Greater", "long", ">", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "Greater", "double", ">", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "GreaterEqual", "long", ">=", "Col", "Scalar"},
+      {"LongDoubleCompareTimestamp", "GreaterEqual", "double", ">=", "Col", "Scalar"},
+
+      {"TimestampCompareLongDouble", "Equal", "long", "==", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "Equal", "double", "==", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "NotEqual", "long", "!=", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "NotEqual", "double", "!=", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "Less", "long", "<", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "Less", "double", "<", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "LessEqual", "long", "<=", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "LessEqual", "double", "<=", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "Greater", "long", ">", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "Greater", "double", ">", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "GreaterEqual", "long", ">=", "Scalar", "Column"},
+      {"TimestampCompareLongDouble", "GreaterEqual", "double", ">=", "Scalar", "Column"},
+
+      {"LongDoubleCompareTimestamp", "Equal", "long", "==", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "Equal", "double", "==", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "NotEqual", "long", "!=", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "NotEqual", "double", "!=", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "Less", "long", "<", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "Less", "double", "<", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "LessEqual", "long", "<=", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "LessEqual", "double", "<=", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "Greater", "long", ">", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "Greater", "double", ">", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "GreaterEqual", "long", ">=", "Scalar", "Column"},
+      {"LongDoubleCompareTimestamp", "GreaterEqual", "double", ">=", "Scalar", "Column"},
+
+      // Filter long/double.
       {"FilterColumnCompareScalar", "Equal", "long", "double", "=="},
       {"FilterColumnCompareScalar", "Equal", "double", "double", "=="},
       {"FilterColumnCompareScalar", "NotEqual", "long", "double", "!="},
@@ -343,46 +515,154 @@ public class GenVectorCode extends Task {
       {"FilterScalarCompareColumn", "GreaterEqual", "long", "long", ">="},
       {"FilterScalarCompareColumn", "GreaterEqual", "double", "long", ">="},
 
-      {"FilterTimestampColumnCompareTimestampScalar", "Equal"},
-      {"FilterTimestampColumnCompareTimestampScalar", "NotEqual"},
-      {"FilterTimestampColumnCompareTimestampScalar", "Less"},
-      {"FilterTimestampColumnCompareTimestampScalar", "LessEqual"},
-      {"FilterTimestampColumnCompareTimestampScalar", "Greater"},
-      {"FilterTimestampColumnCompareTimestampScalar", "GreaterEqual"},
-
-      {"FilterTimestampColumnCompareScalar", "Equal", "long"},
-      {"FilterTimestampColumnCompareScalar", "Equal", "double"},
-      {"FilterTimestampColumnCompareScalar", "NotEqual", "long"},
-      {"FilterTimestampColumnCompareScalar", "NotEqual", "double"},
-      {"FilterTimestampColumnCompareScalar", "Less", "long"},
-      {"FilterTimestampColumnCompareScalar", "Less", "double"},
-      {"FilterTimestampColumnCompareScalar", "LessEqual", "long"},
-      {"FilterTimestampColumnCompareScalar", "LessEqual", "double"},
-      {"FilterTimestampColumnCompareScalar", "Greater", "long"},
-      {"FilterTimestampColumnCompareScalar", "Greater", "double"},
-      {"FilterTimestampColumnCompareScalar", "GreaterEqual", "long"},
-      {"FilterTimestampColumnCompareScalar", "GreaterEqual", "double"},
-
-      {"FilterTimestampScalarCompareTimestampColumn", "Equal"},
-      {"FilterTimestampScalarCompareTimestampColumn", "NotEqual"},
-      {"FilterTimestampScalarCompareTimestampColumn", "Less"},
-      {"FilterTimestampScalarCompareTimestampColumn", "LessEqual"},
-      {"FilterTimestampScalarCompareTimestampColumn", "Greater"},
-      {"FilterTimestampScalarCompareTimestampColumn", "GreaterEqual"},
-
-      {"FilterScalarCompareTimestampColumn", "Equal", "long"},
-      {"FilterScalarCompareTimestampColumn", "Equal", "double"},
-      {"FilterScalarCompareTimestampColumn", "NotEqual", "long"},
-      {"FilterScalarCompareTimestampColumn", "NotEqual", "double"},
-      {"FilterScalarCompareTimestampColumn", "Less", "long"},
-      {"FilterScalarCompareTimestampColumn", "Less", "double"},
-      {"FilterScalarCompareTimestampColumn", "LessEqual", "long"},
-      {"FilterScalarCompareTimestampColumn", "LessEqual", "double"},
-      {"FilterScalarCompareTimestampColumn", "Greater", "long"},
-      {"FilterScalarCompareTimestampColumn", "Greater", "double"},
-      {"FilterScalarCompareTimestampColumn", "GreaterEqual", "long"},
-      {"FilterScalarCompareTimestampColumn", "GreaterEqual", "double"},
-
+      // Base filter timestamp against timestamp used by Timestamp and IntervalDayTime.
+      {"FilterTimestampCompareTimestampBase", "Equal", "==", "Col", "Column"},
+      {"FilterTimestampCompareTimestampBase", "NotEqual", "!=", "Col", "Column"},
+      {"FilterTimestampCompareTimestampBase", "Less", "<", "Col", "Column"},
+      {"FilterTimestampCompareTimestampBase", "LessEqual", "<=", "Col", "Column"},
+      {"FilterTimestampCompareTimestampBase", "Greater", ">", "Col", "Column"},
+      {"FilterTimestampCompareTimestampBase", "GreaterEqual", ">=", "Col", "Column"},
+
+      {"FilterTimestampCompareTimestampBase", "Equal", "==", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestampBase", "NotEqual", "!=", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestampBase", "Less", "<", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestampBase", "LessEqual", "<=", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestampBase", "Greater", ">", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestampBase", "GreaterEqual", ">=", "Col", "Scalar"},
+
+      {"FilterTimestampCompareTimestampBase", "Equal", "==", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestampBase", "NotEqual", "!=", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestampBase", "Less", "<", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestampBase", "LessEqual", "<=", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestampBase", "Greater", ">", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestampBase", "GreaterEqual", ">=", "Scalar", "Column"},
+
+      // Filter timestamp against timestamp, or interval day time against interval day time.
+
+      {"FilterTimestampCompareTimestamp", "Equal", "timestamp", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "NotEqual", "timestamp", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "Less", "timestamp", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "LessEqual", "timestamp", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "Greater", "timestamp", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "GreaterEqual", "timestamp", "Col", "Column"},
+
+      {"FilterTimestampCompareTimestamp", "Equal", "timestamp", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "NotEqual", "timestamp", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "Less", "timestamp", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "LessEqual", "timestamp", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "Greater", "timestamp", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "GreaterEqual", "timestamp", "Col", "Scalar"},
+
+      {"FilterTimestampCompareTimestamp", "Equal", "timestamp", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "NotEqual", "timestamp", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "Less", "timestamp", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "LessEqual", "timestamp", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "Greater", "timestamp", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "GreaterEqual", "timestamp", "Scalar", "Column"},
+
+      {"FilterTimestampCompareTimestamp", "Equal", "interval_day_time", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "NotEqual", "interval_day_time", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "Less", "interval_day_time", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "LessEqual", "interval_day_time", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "Greater", "interval_day_time", "Col", "Column"},
+      {"FilterTimestampCompareTimestamp", "GreaterEqual", "interval_day_time", "Col", "Column"},
+
+      {"FilterTimestampCompareTimestamp", "Equal", "interval_day_time", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "NotEqual", "interval_day_time", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "Less", "interval_day_time", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "LessEqual", "interval_day_time", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "Greater", "interval_day_time", "Col", "Scalar"},
+      {"FilterTimestampCompareTimestamp", "GreaterEqual", "interval_day_time", "Col", "Scalar"},
+
+      {"FilterTimestampCompareTimestamp", "Equal", "interval_day_time", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "NotEqual", "interval_day_time", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "Less", "interval_day_time", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "LessEqual", "interval_day_time", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "Greater", "interval_day_time", "Scalar", "Column"},
+      {"FilterTimestampCompareTimestamp", "GreaterEqual", "interval_day_time", "Scalar", "Column"},
+
+      // Filter timestamp against long (seconds) or double (seconds with fractional
+      // nanoseconds).
+
+      {"FilterTimestampCompareLongDouble", "Equal", "long", "==", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "Equal", "double", "==", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "NotEqual", "long", "!=", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "NotEqual", "double", "!=", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "Less", "long", "<", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "Less", "double", "<", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "LessEqual", "long", "<=", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "LessEqual", "double", "<=", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "Greater", "long", ">", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "Greater", "double", ">", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "GreaterEqual", "long", ">=", "Col", "Column"},
+      {"FilterTimestampCompareLongDouble", "GreaterEqual", "double", ">=", "Col", "Column"},
+
+      {"FilterLongDoubleCompareTimestamp", "Equal", "long", "==", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Equal", "double", "==", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "NotEqual", "long", "!=", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "NotEqual", "double", "!=", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Less", "long", "<", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Less", "double", "<", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "LessEqual", "long", "<=", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "LessEqual", "double", "<=", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Greater", "long", ">", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Greater", "double", ">", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "GreaterEqual", "long", ">=", "Col", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "GreaterEqual", "double", ">=", "Col", "Column"},
+
+      {"FilterTimestampCompareLongDouble", "Equal", "long", "==", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "Equal", "double", "==", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "NotEqual", "long", "!=", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "NotEqual", "double", "!=", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "Less", "long", "<", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "Less", "double", "<", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "LessEqual", "long", "<=", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "LessEqual", "double", "<=", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "Greater", "long", ">", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "Greater", "double", ">", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "GreaterEqual", "long", ">=", "Col", "Scalar"},
+      {"FilterTimestampCompareLongDouble", "GreaterEqual", "double", ">=", "Col", "Scalar"},
+
+      {"FilterLongDoubleCompareTimestamp", "Equal", "long", "==", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "Equal", "double", "==", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "NotEqual", "long", "!=", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "NotEqual", "double", "!=", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "Less", "long", "<", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "Less", "double", "<", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "LessEqual", "long", "<=", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "LessEqual", "double", "<=", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "Greater", "long", ">", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "Greater", "double", ">", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "GreaterEqual", "long", ">=", "Col", "Scalar"},
+      {"FilterLongDoubleCompareTimestamp", "GreaterEqual", "double", ">=", "Col", "Scalar"},
+
+      {"FilterTimestampCompareLongDouble", "Equal", "long", "==", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "Equal", "double", "==", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "NotEqual", "long", "!=", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "NotEqual", "double", "!=", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "Less", "long", "<", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "Less", "double", "<", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "LessEqual", "long", "<=", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "LessEqual", "double", "<=", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "Greater", "long", ">", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "Greater", "double", ">", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "GreaterEqual", "long", ">=", "Scalar", "Column"},
+      {"FilterTimestampCompareLongDouble", "GreaterEqual", "double", ">=", "Scalar", "Column"},
+
+      {"FilterLongDoubleCompareTimestamp", "Equal", "long", "==", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Equal", "double", "==", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "NotEqual", "long", "!=", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "NotEqual", "double", "!=", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Less", "long", "<", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Less", "double", "<", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "LessEqual", "long", "<=", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "LessEqual", "double", "<=", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Greater", "long", ">", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "Greater", "double", ">", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "GreaterEqual", "long", ">=", "Scalar", "Column"},
+      {"FilterLongDoubleCompareTimestamp", "GreaterEqual", "double", ">=", "Scalar", "Column"},
+
+      // String group comparison.
       {"FilterStringGroupColumnCompareStringGroupScalarBase", "Equal", "=="},
       {"FilterStringGroupColumnCompareStringGroupScalarBase", "NotEqual", "!="},
       {"FilterStringGroupColumnCompareStringGroupScalarBase", "Less", "<"},
@@ -476,26 +756,28 @@ public class GenVectorCode extends Task {
       {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "Greater", ">"},
       {"FilterTruncStringScalarCompareStringGroupColumn", "Char", "GreaterEqual", ">="},
 
-      {"FilterDecimalColumnCompareScalar", "Equal", "=="},
-      {"FilterDecimalColumnCompareScalar", "NotEqual", "!="},
-      {"FilterDecimalColumnCompareScalar", "Less", "<"},
-      {"FilterDecimalColumnCompareScalar", "LessEqual", "<="},
-      {"FilterDecimalColumnCompareScalar", "Greater", ">"},
-      {"FilterDecimalColumnCompareScalar", "GreaterEqual", ">="},
-
-      {"FilterDecimalScalarCompareColumn", "Equal", "=="},
-      {"FilterDecimalScalarCompareColumn", "NotEqual", "!="},
-      {"FilterDecimalScalarCompareColumn", "Less", "<"},
-      {"FilterDecimalScalarCompareColumn", "LessEqual", "<="},
-      {"FilterDecimalScalarCompareColumn", "Greater", ">"},
-      {"FilterDecimalScalarCompareColumn", "GreaterEqual", ">="},
-
-      {"FilterDecimalColumnCompareColumn", "Equal", "=="},
-      {"FilterDecimalColumnCompareColumn", "NotEqual", "!="},
-      {"FilterDecimalColumnCompareColumn", "Less", "<"},
-      {"FilterDecimalColumnCompareColumn", "LessEqual", "<="},
-      {"FilterDecimalColumnCompareColumn", "Greater", ">"},
-      {"FilterDecimalColumnCompareColumn", "GreaterEqual", ">="},
+
+      {"FilterDecimalColumnCompareDecimalScalar", "Equal", "=="},
+      {"FilterDecimalColumnCompareDecimalScalar", "NotEqual", "!="},
+      {"FilterDecimalColumnCompareDecimalScalar", "Less", "<"},
+      {"FilterDecimalColumnCompareDecimalScalar", "LessEqual", "<="},
+      {"FilterDecimalColumnCompareDecimalScalar", "Greater", ">"},
+      {"FilterDecimalColumnCompareDecimalScalar", "GreaterEqual", ">="},
+
+      {"FilterDecimalScalarCompareDecimalColumn", "Equal", "=="},
+      {"FilterDecimalScalarCompareDecimalColumn", "NotEqual", "!="},
+      {"FilterDecimalScalarCompareDecimalColumn", "Less", "<"},
+      {"FilterDecimalScalarCompareDecimalColumn", "LessEqual", "<="},
+      {"FilterDecimalScalarCompareDecimalColumn", "Greater", ">"},
+      {"FilterDecimalScalarCompareDecimalColumn", "GreaterEqual", ">="},
+
+      {"FilterDecimalColumnCompareDecimalColumn", "Equal", "=="},
+      {"FilterDecimalColumnCompareDecimalColumn", "NotEqual", "!="},
+      {"FilterDecimalColumnCompareDecimalColumn", "Less", "<"},
+      {"FilterDecimalColumnCompareDecimalColumn", "LessEqual", "<="},
+      {"FilterDecimalColumnCompareDecimalColumn", "Greater", ">"},
+      {"FilterDecimalColumnCompareDecimalColumn", "GreaterEqual", ">="},
+
 
       {"StringGroupScalarCompareStringGroupColumnBase", "Equal", "=="},
       {"StringGroupScalarCompareStringGroupColumnBase", "NotEqual", "!="},
@@ -573,6 +855,9 @@ public class GenVectorCode extends Task {
       {"FilterDecimalColumnBetween", ""},
       {"FilterDecimalColumnBetween", "!"},
 
+      {"FilterTimestampColumnBetween", ""},
+      {"FilterTimestampColumnBetween", "!"},
+
       {"ColumnCompareColumn", "Equal", "long", "double", "=="},
       {"ColumnCompareColumn", "Equal", "double", "double", "=="},
       {"ColumnCompareColumn", "NotEqual", "long", "double", "!="},
@@ -593,58 +878,34 @@ public class GenVectorCode extends Task {
       {"ColumnCompareColumn", "Greater", "double", "long", ">"},
       {"ColumnCompareColumn", "GreaterEqual", "double", "long", ">="},
 
-      // Interval comparisons
+      // Interval year month comparisons
       {"DTIScalarCompareColumn", "Equal", "interval_year_month"},
-      {"DTIScalarCompareColumn", "Equal", "interval_day_time"},
       {"DTIScalarCompareColumn", "NotEqual", "interval_year_month"},
-      {"DTIScalarCompareColumn", "NotEqual", "interval_day_time"},
       {"DTIScalarCompareColumn", "Less", "interval_year_month"},
-      {"DTIScalarCompareColumn", "Less", "interval_day_time"},
       {"DTIScalarCompareColumn", "LessEqual", "interval_year_month"},
-      {"DTIScalarCompareColumn", "LessEqual", "interval_day_time"},
       {"DTIScalarCompareColumn", "Greater", "interval_year_month"},
-      {"DTIScalarCompareColumn", "Greater", "interval_day_time"},
       {"DTIScalarCompareColumn", "GreaterEqual", "interval_year_month"},
-      {"DTIScalarCompareColumn", "GreaterEqual", "interval_day_time"},
 
       {"DTIColumnCompareScalar", "Equal", "interval_year_month"},
-      {"DTIColumnCompareScalar", "Equal", "interval_day_time"},
       {"DTIColumnCompareScalar", "NotEqual", "interval_year_month"},
-      {"DTIColumnCompareScalar", "NotEqual", "interval_day_time"},
       {"DTIColumnCompareScalar", "Less", "interval_year_month"},
-      {"DTIColumnCompareScalar", "Less", "interval_day_time"},
       {"DTIColumnCompareScalar", "LessEqual", "interval_year_month"},
-      {"DTIColumnCompareScalar", "LessEqual", "interval_day_time"},
       {"DTIColumnCompareScalar", "Greater", "interval_year_month"},
-      {"DTIColumnCompareScalar", "Greater", "interval_day_time"},
       {"DTIColumnCompareScalar", "GreaterEqual", "interval_year_month"},
-      {"DTIColumnCompareScalar", "GreaterEqual", "interval_day_time"},
 
       {"FilterDTIScalarCompareColumn", "Equal", "interval_year_month"},
-      {"FilterDTIScalarCompareColumn", "Equal", "interval_day_time"},
       {"FilterDTIScalarCompareColumn", "NotEqual", "interval_year_month"},
-      {"FilterDTIScalarCompareColumn", "NotEqual", "interval_day_time"},
       {"FilterDTIScalarCompareColumn", "Less", "interval_year_month"},
-      {"FilterDTIScalarCompareColumn", "Less", "interval_day_time"},
       {"FilterDTIScalarCompareColumn", "LessEqual", "interval_year_month"},
-      {"FilterDTIScalarCompareColumn", "LessEqual", "interval_day_time"},
       {"FilterDTIScalarCompareColumn", "Greater", "interval_year_month"},
-      {"FilterDTIScalarCompareColumn", "Greater", "interval_day_time"},
       {"FilterDTIScalarCompareColumn", "GreaterEqual", "interval_year_month"},
-      {"FilterDTIScalarCompareColumn", "GreaterEqual", "interval_day_time"},
 
       {"FilterDTIColumnCompareScalar", "Equal", "interval_year_month"},
-      {"FilterDTIColumnCompareScalar", "Equal", "interval_day_time"},
       {"FilterDTIColumnCompareScalar", "NotEqual", "interval_year_month"},
-      {"FilterDTIColumnCompareScalar", "NotEqual", "interval_day_time"},
       {"FilterDTIColumnCompareScalar", "Less", "interval_year_month"},
-      {"FilterDTIColumnCompareScalar", "Less", "interval_day_time"},
       {"FilterDTIColumnCompareScalar", "LessEqual", "interval_year_month"},
-      {"FilterDTIColumnCompareScalar", "LessEqual", "interval_day_time"},
       {"FilterDTIColumnCompareScalar", "Greater", "interval_year_month"},
-      {"FilterDTIColumnCompareScalar", "Greater", "interval_day_time"},
       {"FilterDTIColumnCompareScalar", "GreaterEqual", "interval_year_month"},
-      {"FilterDTIColumnCompareScalar", "GreaterEqual", "interval_day_time"},
 
       // Date comparisons
       {"DTIScalarCompareColumn", "Equal", "date"},
@@ -741,24 +1002,12 @@ public class GenVectorCode extends Task {
       // Casts
       {"ColumnUnaryFunc", "Cast", "long", "double", "", "", "(long)", "", ""},
       {"ColumnUnaryFunc", "Cast", "double", "long", "", "", "(double)", "", ""},
-      {"ColumnUnaryFunc", "CastTimestampToLongVia", "long", "long", "MathExpr.fromTimestamp", "",
-        "", "", "timestamp"},
-      {"ColumnUnaryFunc", "CastTimestampToDoubleVia", "double", "long",
-          "MathExpr.fromTimestampToDouble", "", "", "", "timestamp"},
       {"ColumnUnaryFunc", "CastDoubleToBooleanVia", "long", "double", "MathExpr.toBool", "",
         "", "", ""},
       {"ColumnUnaryFunc", "CastLongToBooleanVia", "long", "long", "MathExpr.toBool", "",
         "", "", ""},
       {"ColumnUnaryFunc", "CastDateToBooleanVia", "long", "long", "MathExpr.toBool", "",
             "", "", "date"},
-      {"ColumnUnaryFunc", "CastTimestampToBooleanVia", "long", "long", "MathExpr.toBool", "",
-            "", "", "timestamp"},
-      {"ColumnUnaryFunc", "CastLongToTimestampVia", "long", "long", "MathExpr.longToTimestamp", "",
-          "", "", ""},
-      {"ColumnUnaryFunc", "CastMillisecondsLongToTimestampVia", "long", "long", "MathExpr.millisecondsLongToTimestamp", "",
-            "", "", ""},
-      {"ColumnUnaryFunc", "CastDoubleToTimestampVia", "long", "double",
-         "MathExpr.doubleToTimestamp", "", "", "", ""},
 
       // Boolean to long is done with an IdentityExpression
       // Boolean to double is done with standard Long to Double cast
@@ -803,6 +1052,11 @@ public class GenVectorCode extends Task {
       {"VectorUDAFMinMaxString", "VectorUDAFMaxString", ">", "max",
           "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: string)"},
 
+      {"VectorUDAFMinMaxTimestamp", "VectorUDAFMaxTimestamp", "<", "max",
+          "_FUNC_(expr) - Returns the maximum value of expr (vectorized, type: timestamp)"},
+      {"VectorUDAFMinMaxTimestamp", "VectorUDAFMinTimestamp", ">", "min",
+          "_FUNC_(expr) - Returns the minimum value of expr (vectorized, type: timestamp)"},
+
         //template, <ClassName>, <ValueType>
         {"VectorUDAFSum", "VectorUDAFSumLong", "long"},
         {"VectorUDAFSum", "VectorUDAFSumDouble", "double"},
@@ -947,26 +1201,36 @@ public class GenVectorCode extends Task {
         generateColumnCompareScalar(tdesc);
       } else if (tdesc[0].equals("ScalarCompareColumn")) {
         generateScalarCompareColumn(tdesc);
-      } else if (tdesc[0].equals("TimestampScalarCompareTimestampColumn")) {
-          generateTimestampScalarCompareTimestampColumn(tdesc);
-      } else if (tdesc[0].equals("ScalarCompareTimestampColumn")) {
-          generateScalarCompareTimestampColumn(tdesc);
-      } else if (tdesc[0].equals("TimestampColumnCompareTimestampScalar")) {
-          generateTimestampColumnCompareTimestampScalar(tdesc);
-      } else if (tdesc[0].equals("TimestampColumnCompareScalar")) {
-          generateTimestampColumnCompareScalar(tdesc);
+
+      } else if (tdesc[0].equals("TimestampCompareTimestampBase")) {
+        generateTimestampCompareTimestampBase(tdesc);
+
+      } else if (tdesc[0].equals("TimestampCompareTimestamp")) {
+        generateTimestampCompareTimestamp(tdesc);
+
+      } else if (tdesc[0].equals("TimestampCompareLongDouble")) {
+        generateTimestampCompareLongDouble(tdesc);
+
+      } else if (tdesc[0].equals("LongDoubleCompareTimestamp")) {
+        generateLongDoubleCompareTimestamp(tdesc);
+
       } else if (tdesc[0].equals("FilterColumnCompareScalar")) {
         generateFilterColumnCompareScalar(tdesc);
       } else if (tdesc[0].equals("FilterScalarCompareColumn")) {
         generateFilterScalarCompareColumn(tdesc);
-      } else if (tdesc[0].equals("FilterTimestampColumnCompareTimestampScalar")) {
-          generateFilterTimestampColumnCompareTimestampScalar(tdesc);
-      } else if (tdesc[0].equals("FilterTimestampColumnCompareScalar")) {
-          generateFilterTimestampColumnCompareScalar(tdesc);
-      } else if (tdesc[0].equals("FilterTimestampScalarCompareTimestampColumn")) {
-          generateFilterTimestampScalarCompareTimestampColumn(tdesc);
-      } else if (tdesc[0].equals("FilterScalarCompareTimestampColumn")) {
-          generateFilterScalarCompareTimestampColumn(tdesc);
+
+      } else if (tdesc[0].equals("FilterTimestampCompareTimestampBase")) {
+        generateFilterTimestampCompareTimestampBase(tdesc);
+
+      } else if (tdesc[0].equals("FilterTimestampCompareTimestamp")) {
+        generateFilterTimestampCompareTimestamp(tdesc);
+
+      } else if (tdesc[0].equals("FilterTimestampCompareLongDouble")) {
+        generateFilterTimestampCompareLongDouble(tdesc);
+
+      } else if (tdesc[0].equals("FilterLongDoubleCompareTimestamp")) {
+        generateFilterLongDoubleCompareTimestamp(tdesc);
+
       } else if (tdesc[0].equals("FilterColumnBetween")) {
         generateFilterColumnBetween(tdesc);
       } else if (tdesc[0].equals("ScalarArithmeticColumn") || tdesc[0].equals("ScalarDivideColumn")) {
@@ -988,7 +1252,9 @@ public class GenVectorCode extends Task {
       } else if (tdesc[0].equals("VectorUDAFMinMaxString")) {
         generateVectorUDAFMinMaxString(tdesc);
       } else if (tdesc[0].equals("VectorUDAFMinMaxDecimal")) {
-        generateVectorUDAFMinMaxDecimal(tdesc);
+        generateVectorUDAFMinMaxObject(tdesc);
+      } else if (tdesc[0].equals("VectorUDAFMinMaxTimestamp")) {
+        generateVectorUDAFMinMaxObject(tdesc);
       } else if (tdesc[0].equals("VectorUDAFSum")) {
         generateVectorUDAFSum(tdesc);
       } else if (tdesc[0].equals("VectorUDAFAvg")) {
@@ -1009,7 +1275,9 @@ public class GenVectorCode extends Task {
         generateFilterTruncStringColumnBetween(tdesc);
       } else if (tdesc[0].equals("FilterDecimalColumnBetween")) {
         generateFilterDecimalColumnBetween(tdesc);
-      } else if (tdesc[0].equals("StringGroupColumnCompareStringGroupScalarBase")) {
+      } else if (tdesc[0].equals("FilterTimestampColumnBetween")) {
+        generateFilterTimestampColumnBetween(tdesc);
+       } else if (tdesc[0].equals("StringGroupColumnCompareStringGroupScalarBase")) {
         generateStringGroupColumnCompareStringGroupScalarBase(tdesc);
       } else if (tdesc[0].equals("StringGroupColumnCompareStringScalar")) {
         generateStringGroupColumnCompareStringScalar(tdesc);
@@ -1037,12 +1305,12 @@ public class GenVectorCode extends Task {
         generateIfExprScalarColumn(tdesc);
       } else if (tdesc[0].equals("IfExprScalarScalar")) {
         generateIfExprScalarScalar(tdesc);
-      } else if (tdesc[0].equals("FilterDecimalColumnCompareScalar")) {
-        generateFilterDecimalColumnCompareScalar(tdesc);
-      } else if (tdesc[0].equals("FilterDecimalScalarCompareColumn")) {
-        generateFilterDecimalScalarCompareColumn(tdesc);
-      } else if (tdesc[0].equals("FilterDecimalColumnCompareColumn")) {
-        generateFilterDecimalColumnCompareColumn(tdesc);
+      } else if (tdesc[0].equals("FilterDecimalColumnCompareDecimalScalar")) {
+        generateFilterDecimalColumnCompareDecimalScalar(tdesc);
+      } else if (tdesc[0].equals("FilterDecimalScalarCompareDecimalColumn")) {
+        generateFilterDecimalScalarCompareDecimalColumn(tdesc);
+      } else if (tdesc[0].equals("FilterDecimalColumnCompareDecimalColumn")) {
+        generateFilterDecimalColumnCompareDecimalColumn(tdesc);
       } else if (tdesc[0].equals("FilterDTIScalarCompareColumn")) {
         generateFilterDTIScalarCompareColumn(tdesc);
       } else if (tdesc[0].equals("FilterDTIColumnCompareScalar")) {
@@ -1057,24 +1325,37 @@ public class GenVectorCode extends Task {
         generateScalarArithmeticColumn(tdesc);
       } else if (tdesc[0].equals("DTIColumnArithmeticDTIColumnNoConvert")) {
         generateColumnArithmeticColumn(tdesc);
-      } else if (tdesc[0].equals("ColumnArithmeticColumnWithConvert")) {
-        generateColumnArithmeticColumnWithConvert(tdesc);
-      } else if (tdesc[0].equals("ScalarArithmeticColumnWithConvert")) {
-        generateScalarArithmeticColumnWithConvert(tdesc);
-      } else if (tdesc[0].equals("ColumnArithmeticScalarWithConvert")) {
-        generateColumnArithmeticScalarWithConvert(tdesc);
-      } else if (tdesc[0].equals("DateTimeColumnArithmeticIntervalColumnWithConvert")) {
-        generateDateTimeColumnArithmeticIntervalColumnWithConvert(tdesc);
-      } else if (tdesc[0].equals("DateTimeScalarArithmeticIntervalColumnWithConvert")) {
-        generateDateTimeScalarArithmeticIntervalColumnWithConvert(tdesc);
-      } else if (tdesc[0].equals("DateTimeColumnArithmeticIntervalScalarWithConvert")) {
-        generateDateTimeColumnArithmeticIntervalScalarWithConvert(tdesc);
-      } else if (tdesc[0].equals("IntervalColumnArithmeticDateTimeColumnWithConvert")) {
-        generateDateTimeColumnArithmeticIntervalColumnWithConvert(tdesc);
-      } else if (tdesc[0].equals("IntervalScalarArithmeticDateTimeColumnWithConvert")) {
-        generateDateTimeScalarArithmeticIntervalColumnWithConvert(tdesc);
-      } else if (tdesc[0].equals("IntervalColumnArithmeticDateTimeScalarWithConvert")) {
-        generateDateTimeColumnArithmeticIntervalScalarWithConvert(tdesc);
+
+      } else if (tdesc[0].equals("DateArithmeticIntervalYearMonth")) {
+        generateDateTimeArithmeticIntervalYearMonth(tdesc);
+
+      } else if (tdesc[0].equals("IntervalYearMonthArithmeticDate")) {
+        generateDateTimeArithmeticIntervalYearMonth(tdesc);
+
+      } else if (tdesc[0].equals("TimestampArithmeticIntervalYearMonth")) {
+        generateDateTimeArithmeticIntervalYearMonth(tdesc);
+
+      } else if (tdesc[0].equals("IntervalYearMonthArithmeticTimestamp")) {
+        generateDateTimeArithmeticIntervalYearMonth(tdesc);
+
+      } else if (tdesc[0].equals("TimestampArithmeticTimestampBase")) {
+        generateTimestampArithmeticTimestampBase(tdesc);
+
+      } else if (tdesc[0].equals("TimestampArithmeticTimestamp")) {
+        generateTimestampArithmeticTimestamp(tdesc);
+
+      } else if (tdesc[0].equals("DateArithmeticTimestampBase")) {
+        generateDateArithmeticTimestampBase(tdesc);
+
+      } else if (tdesc[0].equals("DateArithmeticTimestamp")) {
+        generateDateArithmeticTimestamp(tdesc);
+
+      } else if (tdesc[0].equals("TimestampArithmeticDateBase")) {
+        generateTimestampArithmeticDateBase(tdesc);
+
+      } else if (tdesc[0].equals("TimestampArithmeticDate")) {
+        generateTimestampArithmeticDate(tdesc);
+
       } else {
         continue;
       }
@@ -1140,6 +1421,20 @@ public class GenVectorCode extends Task {
         className, templateString);
   }
 
+  private void generateFilterTimestampColumnBetween(String[] tdesc) throws IOException {
+    String optionalNot = tdesc[1];
+    String className = "FilterTimestampColumn" + (optionalNot.equals("!") ? "Not" : "")
+        + "Between";
+    // Read the template into a string, expand it, and write it.
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String templateString = readFile(templateFile);
+    templateString = templateString.replaceAll("<ClassName>", className);
+    templateString = templateString.replaceAll("<OptionalNot>", optionalNot);
+
+    writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
+        className, templateString);
+  }
+
   private void generateFilterColumnBetween(String[] tdesc) throws Exception {
     String operandType = tdesc[1];
     String optionalNot = tdesc[2];
@@ -1211,7 +1506,7 @@ public class GenVectorCode extends Task {
         className, templateString);
   }
 
-  private void generateVectorUDAFMinMaxDecimal(String[] tdesc) throws Exception {
+  private void generateVectorUDAFMinMaxObject(String[] tdesc) throws Exception {
       String className = tdesc[1];
       String operatorSymbol = tdesc[2];
       String descName = tdesc[3];
@@ -1609,7 +1904,7 @@ public class GenVectorCode extends Task {
     String vectorExprArgType = operandType;
     if (operandType.equals("long")) {
       // interval types can use long version
-      vectorExprArgType = "int_interval_family";
+      vectorExprArgType = "int_interval_year_month";
     }
     // Expand, and write result
     templateString = templateString.replaceAll("<ClassName>", className);
@@ -1646,8 +1941,8 @@ public class GenVectorCode extends Task {
 
     // Toss in timestamp and date.
     if (operandType2.equals("long") && operandType3.equals("long")) {
-      vectorExprArgType2 = "int_datetime_interval_family";
-      vectorExprArgType3 = "int_datetime_interval_family";
+      vectorExprArgType2 = "int_date_interval_year_month";
+      vectorExprArgType3 = "int_date_interval_year_month";
     }
     templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
     templateString = templateString.replaceAll("<VectorExprArgType3>", vectorExprArgType3);
@@ -1679,8 +1974,8 @@ public class GenVectorCode extends Task {
 
     // Toss in timestamp and date.
     if (operandType2.equals("long") && operandType3.equals("long")) {
-      vectorExprArgType2 = "int_datetime_interval_family";
-      vectorExprArgType3 = "int_datetime_interval_family";
+      vectorExprArgType2 = "int_date_interval_year_month";
+      vectorExprArgType3 = "int_date_interval_year_month";
     }
     templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
     templateString = templateString.replaceAll("<VectorExprArgType3>", vectorExprArgType3);
@@ -1711,8 +2006,8 @@ public class GenVectorCode extends Task {
 
     // Toss in timestamp and date.
     if (operandType2.equals("long") && operandType3.equals("long")) {
-      vectorExprArgType2 = "int_datetime_interval_family";
-      vectorExprArgType3 = "int_datetime_interval_family";
+      vectorExprArgType2 = "int_date_interval_year_month";
+      vectorExprArgType3 = "int_date_interval_year_month";
     }
     templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
     templateString = templateString.replaceAll("<VectorExprArgType3>", vectorExprArgType3);
@@ -1843,12 +2138,10 @@ public class GenVectorCode extends Task {
     String vectorExprArgType1 = operandType1;
     String vectorExprArgType2 = operandType2;
 
-    // For column to column only, we toss in timestamp and date.
-    // But {timestamp|date} and scalar must be handled separately.
+    // For column to column only, we toss in date and interval_year_month.
     if (operandType1.equals("long") && operandType2.equals("long")) {
-      // Let comparisons occur for DATE and TIMESTAMP, too.
-      vectorExprArgType1 = "int_datetime_interval_family";
-      vectorExprArgType2 = "int_datetime_interval_family";
+      vectorExprArgType1 = "int_date_interval_year_month";
+      vectorExprArgType2 = "int_date_interval_year_month";
     }
     templateString = templateString.replaceAll("<VectorExprArgType1>", vectorExprArgType1);
     templateString = templateString.replaceAll("<VectorExprArgType2>", vectorExprArgType2);
@@ -1870,25 +2163,51 @@ public class GenVectorCode extends Task {
     }
   }
 
-  private void generateTimestampScalarCompareTimestampColumn(String[] tdesc) throws Exception {
+  // -----------------------------------------------------------------------------------------------
+  //
+  // Filter timestamp against timestamp, long (seconds), and double (seconds with fractional
+  // nanoseconds).
+  //
+  //  Filter  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //  Filter  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   {Long|Double}Column
+  //* Filter  {Long|Double}Col     {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //
+  //  Filter  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampScalar
+  //  Filter  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   {Long|Double}Scalar
+  //* Filter  {Long|Double}Col     {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampScalar
+  //
+  //  Filter  TimestampScalar      {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //  Filter  TimestampScalar      {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   {Long|Double}Column
+  //* Filter  {Long|Double}Scalar  {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //
+  // -----------------------------------------------------------------------------------------------
+
+  private void generateFilterTimestampCompareTimestampBase(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
-    String className = "TimestampScalar" + operatorName + "TimestampColumn";
-    String baseClassName = "org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalar" + operatorName + "LongColumn";
+    String operatorSymbol = tdesc[2];
+    String className = "FilterTimestamp" + tdesc[3] + operatorName + "Timestamp" + tdesc[4] + "Base";
+
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "FilterTimestamp" + (tdesc[3].equals("Col") ? "Column" : tdesc[3]) + "CompareTimestamp" +
+        tdesc[4] + "Base";
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
-    templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
-  private void generateTimestampColumnCompareTimestampScalar(String[] tdesc) throws Exception {
+  private void generateFilterTimestampCompareTimestamp(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
-    String className = "TimestampCol" + operatorName + "TimestampScalar";
-    String baseClassName = "org.apache.hadoop.hive.ql.exec.vector.expressions.LongCol" + operatorName + "LongScalar";
+    String operandType = tdesc[2];
+    String camelCaseOperandType = getCamelCaseType(operandType);
+    String className = "Filter" + camelCaseOperandType + tdesc[3] + operatorName + camelCaseOperandType + tdesc[4];
+    String baseClassName = "FilterTimestamp" + tdesc[3] + operatorName + "Timestamp" + tdesc[4] + "Base";
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "Filter" + camelCaseOperandType + (tdesc[3].equals("Col") ? "Column" : tdesc[3]) + "Compare" + camelCaseOperandType +
+        tdesc[4];
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
     templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
@@ -1896,106 +2215,210 @@ public class GenVectorCode extends Task {
         className, templateString);
   }
 
-  private void generateFilterTimestampColumnCompareTimestampScalar(String[] tdesc) throws Exception {
+  private void generateFilterTimestampCompareLongDouble(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
-    String className = "FilterTimestampCol" + operatorName + "TimestampScalar";
-    String baseClassName = "FilterLongCol" + operatorName + "LongScalar";
+    String operandType = tdesc[2];
+    String camelCaseOperandType = getCamelCaseType(operandType);
+    String operatorSymbol = tdesc[3];
+    String inputColumnVectorType2 = this.getColumnVectorType(operandType);
+
+    String className = "FilterTimestamp" + tdesc[4] + operatorName + camelCaseOperandType + tdesc[5];
+
+    // Timestamp Scalar case becomes use long/double scalar class.
+    String baseClassName;
+    if (tdesc[4].equals("Scalar")) {
+      baseClassName = "org.apache.hadoop.hive.ql.exec.vector.expressions.gen." +
+          "Filter" + camelCaseOperandType + "Scalar" + operatorName + camelCaseOperandType + "Column";
+    } else {
+      baseClassName = "";
+    }
+
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "FilterTimestamp" + (tdesc[4].equals("Col") ? "Column" : tdesc[4]) + "CompareLongDouble" +
+        tdesc[5];
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
-    templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    if (baseClassName.length() > 0) {
+      templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    }
+    templateString = templateString.replaceAll("<OperandType>", operandType);
+    templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+    templateString = templateString.replaceAll("<InputColumnVectorType2>", inputColumnVectorType2);
+    templateString = templateString.replaceAll("<GetTimestampLongDoubleMethod>", timestampLongDoubleMethod(operandType));
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
-  private void generateFilterTimestampScalarCompareTimestampColumn(String[] tdesc) throws Exception {
+  private void generateFilterLongDoubleCompareTimestamp(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
-    String className = "FilterTimestampScalar" + operatorName + "TimestampColumn";
-    String baseClassName = "FilterLongScalar" + operatorName + "LongColumn";
+    String operandType = tdesc[2];
+    String camelCaseOperandType = getCamelCaseType(operandType);
+    String operatorSymbol = tdesc[3];
+    String inputColumnVectorType1 = this.getColumnVectorType(operandType);
+
+    String className = "Filter" + getCamelCaseType(operandType) + tdesc[4] + operatorName + "Timestamp" + tdesc[5];
+
+    // Timestamp Scalar case becomes use long/double scalar class.
+    String baseClassName;
+    if (tdesc[5].equals("Scalar")) {
+      baseClassName = "org.apache.hadoop.hive.ql.exec.vector.expressions.gen." +
+          "Filter" + camelCaseOperandType + "Col" + operatorName + camelCaseOperandType + "Scalar";
+    } else {
+      baseClassName = "";
+    }
+
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "FilterLongDouble" + (tdesc[4].equals("Col") ? "Column" : tdesc[4]) + "CompareTimestamp" +
+        tdesc[5];
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
-    templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    if (baseClassName.length() > 0) {
+      templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    }
+    templateString = templateString.replaceAll("<OperandType>", operandType);
+    templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+    templateString = templateString.replaceAll("<InputColumnVectorType1>", inputColumnVectorType1);
+    templateString = templateString.replaceAll("<GetTimestampLongDoubleMethod>", timestampLongDoubleMethod(operandType));
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
-  private String timestampScalarConversion(String operandType) {
+  private String timestampLongDoubleMethod(String operandType) {
     if (operandType.equals("long")) {
-      return "secondsToNanoseconds";
+      return "getTimestampSeconds";
     } else if (operandType.equals("double")) {
-      return "doubleToNanoseconds";
+      return "getTimestampSecondsWithFractionalNanos";
     } else {
       return "unknown";
     }
   }
 
-  private void generateScalarCompareTimestampColumn(String[] tdesc) throws Exception {
+  // -----------------------------------------------------------------------------------------------
+  //
+  // Compare timestamp against timestamp, long (seconds), and double (seconds with fractional
+  // nanoseconds).
+  //
+  //  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   {Long|Double}Column
+  //* {Long|Double}Col     {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //
+  //  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampScalar
+  //  TimestampCol         {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   {Long|Double}Scalar
+  //* {Long|Double}Col     {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampScalar
+  //
+  //  TimestampScalar      {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //  TimestampScalar      {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   {Long|Double}Column
+  //* {Long|Double}Scalar  {Equal|Greater|GreaterEqual|Less|LessEqual|NotEqual}   TimestampColumn
+  //
+  // -----------------------------------------------------------------------------------------------
+
+  private void generateTimestampCompareTimestampBase(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
-    String operandType = tdesc[2];
-    String className = getCamelCaseType(operandType) + "Scalar" + operatorName + "TimestampColumn";
-    String baseClassName = "org.apache.hadoop.hive.ql.exec.vector.expressions.LongScalar" + operatorName + "LongColumn";
+    String operatorSymbol = tdesc[2];
+    String className = "Timestamp" + tdesc[3] + operatorName + "Timestamp" + tdesc[4] + "Base";
+
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "Timestamp" + (tdesc[3].equals("Col") ? "Column" : tdesc[3]) + "CompareTimestamp" +
+        tdesc[4] + "Base";
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
-    templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
-    templateString = templateString.replaceAll("<OperandType>", operandType);
-    templateString = templateString.replaceAll("<TimestampScalarConversion>", timestampScalarConversion(operandType));
+    templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
-  private void generateTimestampColumnCompareScalar(String[] tdesc) throws Exception {
+  private void generateTimestampCompareTimestamp(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
     String operandType = tdesc[2];
-    String className = "TimestampCol" + operatorName + getCamelCaseType(operandType) + "Scalar";
-    String baseClassName = "org.apache.hadoop.hive.ql.exec.vector.expressions.LongCol" + operatorName + "LongScalar";
+    String camelCaseOperandType = getCamelCaseType(operandType);
+    String className = camelCaseOperandType + tdesc[3] + operatorName + camelCaseOperandType + tdesc[4];
+    String baseClassName = "Timestamp" + tdesc[3] + operatorName + "Timestamp" + tdesc[4] + "Base";
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = camelCaseOperandType + (tdesc[3].equals("Col") ? "Column" : tdesc[3]) + "Compare" + camelCaseOperandType +
+        tdesc[4];
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
     templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
-    templateString = templateString.replaceAll("<OperandType>", operandType);
-    templateString = templateString.replaceAll("<TimestampScalarConversion>", timestampScalarConversion(operandType));
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
-  private void generateFilterTimestampColumnCompareScalar(String[] tdesc) throws Exception {
+  private void generateTimestampCompareLongDouble(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
     String operandType = tdesc[2];
-    String className = "FilterTimestampCol" + operatorName + getCamelCaseType(operandType) + "Scalar";
-    String baseClassName = "FilterLongCol" + operatorName + "LongScalar";
+    String camelCaseOperandType = getCamelCaseType(operandType);
+    String operatorSymbol = tdesc[3];
+    String inputColumnVectorType2 = this.getColumnVectorType(operandType);
+
+    String className = "Timestamp" + tdesc[4] + operatorName + getCamelCaseType(operandType) + tdesc[5];
+
+
+    // Timestamp Scalar case becomes use long/double scalar class.
+    String baseClassName;
+    if (tdesc[4].equals("Scalar")) {
+      baseClassName = camelCaseOperandType + "Scalar" + operatorName + camelCaseOperandType + "Column";
+    } else {
+      baseClassName = "";
+    }
+
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "Timestamp" + (tdesc[4].equals("Col") ? "Column" : tdesc[4]) + "CompareLongDouble" +
+        tdesc[5];
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
-    templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    if (baseClassName.length() > 0) {
+      templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    }
     templateString = templateString.replaceAll("<OperandType>", operandType);
-    templateString = templateString.replaceAll("<TimestampScalarConversion>", timestampScalarConversion(operandType));
+    templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+    templateString = templateString.replaceAll("<InputColumnVectorType2>", inputColumnVectorType2);
+    templateString = templateString.replaceAll("<GetTimestampLongDoubleMethod>", timestampLongDoubleMethod(operandType));
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
-  private void generateFilterScalarCompareTimestampColumn(String[] tdesc) throws Exception {
+  private void generateLongDoubleCompareTimestamp(String[] tdesc) throws Exception {
     String operatorName = tdesc[1];
     String operandType = tdesc[2];
-    String className = "Filter" + getCamelCaseType(operandType) + "Scalar" + operatorName + "TimestampColumn";
-    String baseClassName = "FilterLongScalar" + operatorName + "LongColumn";
+    String camelCaseOperandType = getCamelCaseType(operandType);
+    String operatorSymbol = tdesc[3];
+    String inputColumnVectorType1 = this.getColumnVectorType(operandType);
+
+    String className = getCamelCaseType(operandType) + tdesc[4] + operatorName + "Timestamp" + tdesc[5];
+
+    // Timestamp Scalar case becomes use long/double scalar class.
+    String baseClassName;
+    if (tdesc[5].equals("Scalar")) {
+      baseClassName = camelCaseOperandType + "Col" + operatorName + camelCaseOperandType + "Scalar";
+    } else {
+      baseClassName = "";
+    }
+
     //Read the template into a string;
-    File templateFile = new File(joinPath(this.expressionTemplateDirectory, tdesc[0] + ".txt"));
+    String fileName = "LongDouble" + (tdesc[4].equals("Col") ? "Column" : tdesc[4]) + "CompareTimestamp" +
+        tdesc[5];
+    File templateFile = new File(joinPath(this.expressionTemplateDirectory, fileName + ".txt"));
     String templateString = readFile(templateFile);
     templateString = templateString.replaceAll("<ClassName>", className);
-    templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    if (baseClassName.length() > 0) {
+      templateString = templateString.replaceAll("<BaseClassName>", baseClassName);
+    }
     templateString = templateString.replaceAll("<OperandType>", operandType);
-    templateString = templateString.replaceAll("<TimestampScalarConversion>", timestampScalarConversion(operandType));
+    templateString = templateString.replaceAll("<OperatorSymbol>", operatorSymbol);
+    templateString = templateString.replaceAll("<InputColumnVectorType1>", inputColumnVectorType1);
+    templateString = templateString.replaceAll("<GetTimestampLongDoubleMethod>", timestampLongDoubleMethod(operandType));
     writeFile(templateFile.lastModified(), expressionOutputDirectory, expressionClassesDirectory,
         className, templateString);
   }
 
+  // -----------------------------------------------------------------------------------------------
+  //
+  // -----------------------------------------------------------------------------------------------
 
   private void generateColumnArithmeticOperatorColumn(String[] tdesc, String returnType,
          String className) throws Exception {
@@ -2098,7 +2521,7 @@ public class GenVectorCode extends Task {
         className, templateString);
 
     String testScalarType = operandType2;
-    if (isDateTimeIntervalType(testScalarType)) {
+    if (isDateIntervalType(testScalarType)) {
       testScalarType = "long";
     }
 
@@ -2180,7 +2603,7 @@ public class GenVectorCode extends Task {
         className, templateString);
 
      String testScalarType = operandType1;
-     if (isDateTimeIntervalType(testScalarType)) {
+     if (isDateIntervalType(testScalarType)) {
        testScalarType = "long";
      }
 
@@ -2297,19 +2720,19 @@ public class GenVectorCode extends Task {
     generateScalarArithmeticOperatorColumn(tdesc, returnType, className);
   }
 
-  private void generateFilterDecimalColumnCompareScalar(String[] tdesc) throws IOException {
+  private void generateFilterDecimalColumnCompareDecimalScalar(String[] tdesc) throws IOException {
     String operatorName = tdesc[1];
     String className = "FilterDecimalCol" + operatorName + "DecimalScalar";
     generateDecimalColumnCompare(tdesc, className);
   }
 
-  private void generateFilterDecimalScalarCompareColumn(String[] tdesc) throws IOException {
+  private void generateFilterDecimalScalarCompareDecimalColumn(String[] tdesc) throws IOException {
     String operatorName = tdesc[1];
     String className = "FilterDecimalScalar" + operatorName + "DecimalColumn";
     generateDecimalColumnCompare(tdesc, className);
   }
 
-  private void generateFilterDecimalColumnCompareColumn(String[] tdesc) throws IOException {
+  private void generateFilterDecimalColumnCompareDecimalColumn(String[] tdesc) throws IOException {
     String operatorName = tdesc[1];
     String className = "FilterDecimalCol" + operatorName + "DecimalColumn";
     generateDecimalColumnCompare(tdesc, className);
@@ -2395,310 +2818,332 @@ public class GenVectorCode extends Task {
         className, templateString);
   }
 
-  private void generateColumnArithmeticColumnWithConvert(String[] tdesc) throws Exception {
+  // DateColumnArithmeticIntervalYearMonthColumn.txt
+  // DateScalarArithmeticIntervalYearMonthColumn.txt
+  // DateColumnArithmeticIntervalYearMonthScalar.txt
+  //
+  // IntervalYearMonthColumnArithmeticDateColumn.txt
+  // IntervalYearMonthScalarArithmeticDateColumn.txt
+  // IntervalYearMonthColumnArithmeticDateScalar.txt
+  //
+  // TimestampColumnArithmeticIntervalYearMonthColumn.txt
+  // TimestampScalarArithmeticIntervalYearMonthColumn.txt
+  // TimestampColumnArithmeticIntervalYearMonthScalar.txt
+  //
+  // IntervalYearMonthColumnArithmeticTimestampColumn.txt
+  // IntervalYearMonthScalarArithmeticTimestampColumn.txt
+  // IntervalYearMonthColumnArithmeticTimestampS

<TRUNCATED>

Mime
View raw message