You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by mm...@apache.org on 2016/04/10 08:02:38 UTC
[15/16] hive git commit: HIVE-9862 Vectorized execution corrupts
timestamp values (Matt McCline, reviewed by Jason Dere)
http://git-wip-us.apache.org/repos/asf/hive/blob/4a479d0c/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>