This is an automated email from the ASF dual-hosted git repository.
MaxGekk pushed a commit to branch branch-4.x
in repository https://gitbox.apache.org/repos/asf/spark.git
The following commit(s) were added to refs/heads/branch-4.x by this push:
new 1c8cfd4bc346 [SPARK-57501][SQL] Add +/- ANSI day-time interval support
for TIMESTAMP_NTZ/LTZ(p)
1c8cfd4bc346 is described below
commit 1c8cfd4bc34640d19aa47af46dad44261e3e2ec7
Author: Maxim Gekk <[email protected]>
AuthorDate: Thu Jun 18 07:36:57 2026 +0200
[SPARK-57501][SQL] Add +/- ANSI day-time interval support for
TIMESTAMP_NTZ/LTZ(p)
### What changes were proposed in this pull request?
This PR adds support for `TIMESTAMP_NTZ(p)` / `TIMESTAMP_LTZ(p)` (`p in [7,
9]`) in `+/- ANSI day-time interval` arithmetic.
Concretely:
- Extends `TimestampAddInterval` input typing to accept nanos timestamp
types alongside existing microsecond timestamp types.
- Adds nanos-aware execution/codegen paths for ANSI day-time interval
arithmetic that preserve `nanosWithinMicro` while applying interval arithmetic
on epoch micros.
- Keeps nanos timestamp arithmetic scoped to ANSI day-time intervals:
`CalendarIntervalType` with nanos timestamps now reports a type mismatch.
- Adds utility helpers in `DateTimeUtils` to keep nanos remainder unchanged
during timestamp +/- day-time interval operations.
- Adds catalyst and SQL test coverage for NTZ/LTZ nanos interval arithmetic
parity.
- Regenerates impacted SQL golden files, including analyzer outputs where
`requiredType` now correctly reports both micro and nanos timestamp families.
A small follow-up commit in this branch removes temporary helper
abstractions (`AnyTimestampFamilyType` / `AnyTimestampFamilyTypeExpression`)
and keeps the change scoped without widening `SubtractTimestamps` handling.
### Why are the changes needed?
Spark already supports timestamp +/- ANSI day-time interval for microsecond
timestamp families, but nanos timestamp families (`TIMESTAMP_NTZ(p)` /
`TIMESTAMP_LTZ(p)`, `p in [7, 9]`) lacked parity. This left valid datetime
arithmetic unsupported for nanos types.
These changes close that parity gap while preserving nanos precision
semantics and existing LTZ/NTZ timezone behavior.
### Does this PR introduce _any_ user-facing change?
Yes.
`TIMESTAMP_NTZ(p)` / `TIMESTAMP_LTZ(p)` (`p in [7, 9]`) now support `+/-
ANSI day-time interval` arithmetic.
For nanos timestamps, `CalendarIntervalType` is rejected with a type
mismatch and users should use ANSI day-time intervals.
Examples:
- `TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '2
00:03:00.000456' DAY TO SECOND`
- `TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' - INTERVAL '1
00:04:00.000321' DAY TO SECOND`
### How was this patch tested?
- `build/sbt 'catalyst/testOnly
org.apache.spark.sql.catalyst.expressions.DateExpressionsSuite'`
- `SPARK_GENERATE_GOLDEN_FILES=1 build/sbt 'sql/testOnly
org.apache.spark.sql.SQLQueryTestSuite -- -z "timestamp-ntz-nanos"'`
- `SPARK_GENERATE_GOLDEN_FILES=1 build/sbt 'sql/testOnly
org.apache.spark.sql.SQLQueryTestSuite -- -z "timestamp-ltz-nanos"'`
- `SPARK_GENERATE_GOLDEN_FILES=1 build/sbt 'sql/testOnly
org.apache.spark.sql.SQLQueryTestSuite -- -z "interval"'`
- `./dev/scalastyle`
- `./build/mvn scalafmt:format -Dscalafmt.skip=false
-Dscalafmt.validateOnly=false -Dscalafmt.changedOnly=false -pl sql/api -pl
sql/connect/common -pl sql/connect/server -pl sql/connect/shims -pl
sql/connect/client/jvm`
### Was this patch authored or co-authored using generative AI tooling?
Generated-by: Cursor Codex 5.3
Closes #56562 from MaxGekk/nanos-ansi-intervals.
Authored-by: Maxim Gekk <[email protected]>
Signed-off-by: Max Gekk <[email protected]>
(cherry picked from commit dea9c30499ba860297cbf49d85c712a6f6767da6)
Signed-off-by: Max Gekk <[email protected]>
---
.../catalyst/expressions/datetimeExpressions.scala | 56 +++++++++++++++-
.../spark/sql/catalyst/util/DateTimeUtils.scala | 12 ++++
.../expressions/DateExpressionsSuite.scala | 71 ++++++++++++++++++++
.../sql/catalyst/util/DateTimeUtilsSuite.scala | 45 +++++++++++++
.../sql-tests/analyzer-results/interval.sql.out | 10 +--
.../analyzer-results/nonansi/interval.sql.out | 10 +--
.../nonansi/try_arithmetic.sql.out | 2 +-
.../analyzer-results/timestamp-ltz-nanos.sql.out | 70 ++++++++++++++++++++
.../analyzer-results/timestamp-ntz-nanos.sql.out | 67 +++++++++++++++++++
.../analyzer-results/try_arithmetic.sql.out | 2 +-
.../typeCoercion/native/dateTimeOperations.sql.out | 54 +++++++--------
.../sql-tests/inputs/timestamp-ltz-nanos.sql | 13 ++++
.../sql-tests/inputs/timestamp-ntz-nanos.sql | 10 +++
.../resources/sql-tests/results/interval.sql.out | 10 +--
.../sql-tests/results/nonansi/interval.sql.out | 10 +--
.../results/nonansi/try_arithmetic.sql.out | 2 +-
.../sql-tests/results/timestamp-ltz-nanos.sql.out | 77 ++++++++++++++++++++++
.../sql-tests/results/timestamp-ntz-nanos.sql.out | 74 +++++++++++++++++++++
.../sql-tests/results/try_arithmetic.sql.out | 2 +-
.../typeCoercion/native/dateTimeOperations.sql.out | 54 +++++++--------
20 files changed, 570 insertions(+), 81 deletions(-)
diff --git
a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/datetimeExpressions.scala
b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/datetimeExpressions.scala
index 3db0e7a42509..f7d4ae2364bf 100644
---
a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/datetimeExpressions.scala
+++
b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/datetimeExpressions.scala
@@ -1789,7 +1789,46 @@ case class TimestampAddInterval(
override def toString: String = s"$left + $right"
override def sql: String = s"${left.sql} + ${right.sql}"
override def inputTypes: Seq[AbstractDataType] =
- Seq(AnyTimestampType, TypeCollection(CalendarIntervalType,
DayTimeIntervalType))
+ Seq(
+ TypeCollection(AnyTimestampType, AnyTimestampNanoType),
+ TypeCollection(CalendarIntervalType, DayTimeIntervalType))
+
+ override def checkInputDataTypes(): TypeCheckResult = {
+ val leftIsTimestamp = AnyTimestampType.acceptsType(left.dataType)
+ val leftIsTimestampNanos = left.dataType.isInstanceOf[AnyTimestampNanoType]
+
+ if (!leftIsTimestamp && !leftIsTimestampNanos) {
+ DataTypeMismatch(
+ errorSubClass = "UNEXPECTED_INPUT_TYPE",
+ messageParameters = Map(
+ "paramIndex" -> ordinalNumber(0),
+ "requiredType" -> toSQLType(TypeCollection(AnyTimestampType,
AnyTimestampNanoType)),
+ "inputSql" -> toSQLExpr(left),
+ "inputType" -> toSQLType(left.dataType)))
+ } else {
+ right.dataType match {
+ case _: DayTimeIntervalType => TypeCheckSuccess
+ case CalendarIntervalType if leftIsTimestampNanos =>
+ DataTypeMismatch(
+ errorSubClass = "UNEXPECTED_INPUT_TYPE",
+ messageParameters = Map(
+ "paramIndex" -> ordinalNumber(1),
+ "requiredType" -> toSQLType(DayTimeIntervalType()),
+ "inputSql" -> toSQLExpr(right),
+ "inputType" -> toSQLType(right.dataType)))
+ case CalendarIntervalType => TypeCheckSuccess
+ case _ =>
+ DataTypeMismatch(
+ errorSubClass = "UNEXPECTED_INPUT_TYPE",
+ messageParameters = Map(
+ "paramIndex" -> ordinalNumber(1),
+ "requiredType" ->
+ toSQLType(TypeCollection(CalendarIntervalType,
DayTimeIntervalType)),
+ "inputSql" -> toSQLExpr(right),
+ "inputType" -> toSQLType(right.dataType)))
+ }
+ }
+ }
override def dataType: DataType = start.dataType
@@ -1800,7 +1839,13 @@ case class TimestampAddInterval(
override def nullSafeEval(start: Any, interval: Any): Any = right.dataType
match {
case _: DayTimeIntervalType =>
- timestampAddDayTime(start.asInstanceOf[Long],
interval.asInstanceOf[Long], zoneIdInEval)
+ left.dataType match {
+ case _: AnyTimestampNanoType =>
+ timestampNanosAddDayTime(
+ start.asInstanceOf[TimestampNanosVal],
interval.asInstanceOf[Long], zoneIdInEval)
+ case _ =>
+ timestampAddDayTime(start.asInstanceOf[Long],
interval.asInstanceOf[Long], zoneIdInEval)
+ }
case CalendarIntervalType =>
val i = interval.asInstanceOf[CalendarInterval]
timestampAddInterval(start.asInstanceOf[Long], i.months, i.days,
i.microseconds, zoneIdInEval)
@@ -1811,7 +1856,12 @@ case class TimestampAddInterval(
val dtu = DateTimeUtils.getClass.getName.stripSuffix("$")
interval.dataType match {
case _: DayTimeIntervalType =>
- defineCodeGen(ctx, ev, (sd, dt) => s"""$dtu.timestampAddDayTime($sd,
$dt, $zid)""")
+ left.dataType match {
+ case _: AnyTimestampNanoType =>
+ defineCodeGen(ctx, ev, (sd, dt) =>
s"""$dtu.timestampNanosAddDayTime($sd, $dt, $zid)""")
+ case _ =>
+ defineCodeGen(ctx, ev, (sd, dt) =>
s"""$dtu.timestampAddDayTime($sd, $dt, $zid)""")
+ }
case CalendarIntervalType =>
defineCodeGen(ctx, ev, (sd, i) => {
s"""$dtu.timestampAddInterval($sd, $i.months, $i.days,
$i.microseconds, $zid)"""
diff --git
a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/util/DateTimeUtils.scala
b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/util/DateTimeUtils.scala
index 38263a7ebc1c..104446ecd5ba 100644
---
a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/util/DateTimeUtils.scala
+++
b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/util/DateTimeUtils.scala
@@ -305,6 +305,18 @@ object DateTimeUtils extends SparkDateTimeUtils {
instantToMicros(resultTimestamp.toInstant)
}
+ /**
+ * Adds a day-time interval to a nanosecond-precision timestamp value while
preserving
+ * the `nanosWithinMicro` remainder.
+ */
+ def timestampNanosAddDayTime(
+ start: TimestampNanosVal,
+ dayTime: Long,
+ zoneId: ZoneId): TimestampNanosVal = {
+ val epochMicros = timestampAddDayTime(start.epochMicros, dayTime, zoneId)
+ TimestampNanosVal.fromParts(epochMicros, start.nanosWithinMicro)
+ }
+
/**
* Adds a full interval (months, days, microseconds) to a timestamp
represented as the number of
* microseconds since 1970-01-01 00:00:00Z.
diff --git
a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/DateExpressionsSuite.scala
b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/DateExpressionsSuite.scala
index 2ffc30b3d7c4..783e6e856359 100644
---
a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/DateExpressionsSuite.scala
+++
b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/DateExpressionsSuite.scala
@@ -1896,6 +1896,77 @@ class DateExpressionsSuite extends SparkFunSuite with
ExpressionEvalHelper {
}
}
+ test("SPARK-57501: add/subtract ANSI day-time interval on nanos timestamps")
{
+ val interval = Duration.ofDays(2).plusMinutes(3).plus(456,
ChronoUnit.MICROS)
+ val minusInterval = Duration.ofDays(-1).minusMinutes(4).minus(321,
ChronoUnit.MICROS)
+
+ val ntzType = TimestampNTZNanosType(9)
+ val ntzStart = DateTimeUtils.localDateTimeToTimestampNanos(
+ LocalDateTime.parse("2020-01-02T03:04:05.123456789"), precision = 9)
+ val ntzExpectedAdd = DateTimeUtils.localDateTimeToTimestampNanos(
+ LocalDateTime.parse("2020-01-04T03:07:05.123912789"), precision = 9)
+ val ntzExpectedSub = DateTimeUtils.localDateTimeToTimestampNanos(
+ LocalDateTime.parse("2020-01-01T03:00:05.123135789"), precision = 9)
+
+ checkEvaluation(
+ TimestampAddInterval(Literal.create(ntzStart, ntzType),
Literal(interval), Some("UTC")),
+ ntzExpectedAdd)
+ checkEvaluation(
+ TimestampAddInterval(
+ Literal.create(ntzStart, ntzType),
+ UnaryMinus(Literal(interval)),
+ Some("UTC")),
+ DateTimeUtils.localDateTimeToTimestampNanos(
+ LocalDateTime.parse("2019-12-31T03:01:05.123000789"), precision = 9))
+ checkEvaluation(
+ TimestampAddInterval(Literal.create(ntzStart, ntzType),
Literal(minusInterval), Some("UTC")),
+ ntzExpectedSub)
+ assert(ntzExpectedAdd.nanosWithinMicro == ntzStart.nanosWithinMicro)
+ assert(ntzExpectedSub.nanosWithinMicro == ntzStart.nanosWithinMicro)
+
+ val ltzType = TimestampLTZNanosType(9)
+ val ltzStart = DateTimeUtils.instantToTimestampNanos(
+ Instant.parse("2020-01-02T03:04:05.123456789Z"), precision = 9)
+ val ltzExpectedAdd = DateTimeUtils.instantToTimestampNanos(
+ Instant.parse("2020-01-04T03:07:05.123912789Z"), precision = 9)
+ val ltzExpectedSub = DateTimeUtils.instantToTimestampNanos(
+ Instant.parse("2020-01-01T03:00:05.123135789Z"), precision = 9)
+
+ checkEvaluation(
+ TimestampAddInterval(Literal.create(ltzStart, ltzType),
Literal(interval), Some("UTC")),
+ ltzExpectedAdd)
+ checkEvaluation(
+ TimestampAddInterval(
+ Literal.create(ltzStart, ltzType),
+ UnaryMinus(Literal(interval)),
+ Some("UTC")),
+ DateTimeUtils.instantToTimestampNanos(
+ Instant.parse("2019-12-31T03:01:05.123000789Z"), precision = 9))
+ checkEvaluation(
+ TimestampAddInterval(Literal.create(ltzStart, ltzType),
Literal(minusInterval), Some("UTC")),
+ ltzExpectedSub)
+ assert(ltzExpectedAdd.nanosWithinMicro == ltzStart.nanosWithinMicro)
+ assert(ltzExpectedSub.nanosWithinMicro == ltzStart.nanosWithinMicro)
+
+ checkConsistencyBetweenInterpretedAndCodegen(
+ (ts: Expression, dt: Expression) => TimestampAddInterval(ts, dt,
Some("UTC")),
+ ntzType, DayTimeIntervalType())
+ checkConsistencyBetweenInterpretedAndCodegen(
+ (ts: Expression, dt: Expression) => TimestampAddInterval(ts, dt,
Some("UTC")),
+ ltzType, DayTimeIntervalType())
+
+ val calendarInterval = Literal(new CalendarInterval(1, 2, 3L))
+ val ntzCalendar = TimestampAddInterval(
+ Literal.create(ntzStart, ntzType), calendarInterval, Some("UTC"))
+ val ntzMismatch =
ntzCalendar.checkInputDataTypes().asInstanceOf[DataTypeMismatch]
+ assert(ntzMismatch.errorSubClass == "UNEXPECTED_INPUT_TYPE")
+
+ val ltzCalendar = TimestampAddInterval(
+ Literal.create(ltzStart, ltzType), calendarInterval, Some("UTC"))
+ val ltzMismatch =
ltzCalendar.checkInputDataTypes().asInstanceOf[DataTypeMismatch]
+ assert(ltzMismatch.errorSubClass == "UNEXPECTED_INPUT_TYPE")
+ }
+
test("SPARK-37552: convert a timestamp_ntz to another time zone") {
checkEvaluation(
ConvertTimezone(
diff --git
a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/DateTimeUtilsSuite.scala
b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/DateTimeUtilsSuite.scala
index 8256da9fb3f9..8db143507819 100644
---
a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/DateTimeUtilsSuite.scala
+++
b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/DateTimeUtilsSuite.scala
@@ -1127,6 +1127,51 @@ class DateTimeUtilsSuite extends SparkFunSuite with
Matchers with SQLHelper {
date(2019, 11, 3, 12, 0, 0, 123000, LA))
}
+ test("SPARK-57501: timestamp nanos add day-time interval preserves
nanosWithinMicro") {
+ def nanos(epochMicros: Long, nanosWithinMicro: Int): TimestampNanosVal =
+ TimestampNanosVal.fromParts(epochMicros, nanosWithinMicro.toShort)
+
+ // The epoch-micros part follows the micro `timestampAddDayTime`
(including the transition from
+ // Pacific Standard to Pacific Daylight Time) while the sub-microsecond
remainder is carried
+ // through unchanged.
+ assert(timestampNanosAddDayTime(
+ nanos(date(2019, 3, 9, 12, 0, 0, 123000, LA), 789), MICROS_PER_DAY, LA)
===
+ nanos(date(2019, 3, 10, 12, 0, 0, 123000, LA), 789))
+
+ outstandingZoneIds.foreach { zid =>
+ // The sub-microsecond remainder is preserved for the boundary values 0,
1 and 999.
+ Seq(0, 1, 999).foreach { rem =>
+ // Zero interval is a no-op on both the epoch-micros and the remainder.
+ assert(timestampNanosAddDayTime(
+ nanos(date(2021, 3, 18, 19, 44, 1, 100000, zid), rem), 0, zid) ===
+ nanos(date(2021, 3, 18, 19, 44, 1, 100000, zid), rem))
+ // Subtracting whole days shifts only the epoch-micros part.
+ assert(timestampNanosAddDayTime(
+ nanos(date(2021, 1, 19, 0, 0, 0, 0, zid), rem), -18 *
MICROS_PER_DAY, zid) ===
+ nanos(date(2021, 1, 1, 0, 0, 0, 0, zid), rem))
+ // A +1 microsecond carry from the day-time interval only moves
epochMicros
+ // (123456 -> 123457), never the remainder.
+ assert(timestampNanosAddDayTime(
+ nanos(date(2019, 5, 9, 12, 0, 0, 123456, zid), rem), 2 *
MICROS_PER_DAY + 1, zid) ===
+ nanos(date(2019, 5, 11, 12, 0, 0, 123457, zid), rem))
+ // Pre-epoch (negative epochMicros) value.
+ assert(timestampNanosAddDayTime(
+ nanos(date(1960, 1, 2, 3, 4, 5, 123456, zid), rem), MICROS_PER_DAY,
zid) ===
+ nanos(date(1960, 1, 3, 3, 4, 5, 123456, zid), rem))
+ }
+ }
+
+ // Consistency with the micro helper: epochMicros matches
`timestampAddDayTime` exactly and the
+ // remainder is independent of the interval amount.
+ outstandingZoneIds.foreach { zid =>
+ val start = nanos(date(2020, 1, 2, 3, 4, 5, 123456, zid), 789)
+ val dayTime = 3 * MICROS_PER_HOUR + 7
+ val result = timestampNanosAddDayTime(start, dayTime, zid)
+ assert(result.epochMicros === timestampAddDayTime(start.epochMicros,
dayTime, zid))
+ assert(result.nanosWithinMicro === start.nanosWithinMicro)
+ }
+ }
+
test("SPARK-34903: subtract timestamps") {
DateTimeTestUtils.outstandingZoneIds.foreach { zid =>
Seq(
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/interval.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/interval.sql.out
index 88121e4dc3c2..eb9bc4d913de 100644
--- a/sql/core/src/test/resources/sql-tests/analyzer-results/interval.sql.out
+++ b/sql/core/src/test/resources/sql-tests/analyzer-results/interval.sql.out
@@ -1721,7 +1721,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -1745,7 +1745,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -1769,7 +1769,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + (- INTERVAL '3' DAY)\""
},
"queryContext" : [ {
@@ -1815,7 +1815,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + (- INTERVAL '02' SECOND)\""
},
"queryContext" : [ {
@@ -1861,7 +1861,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/interval.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/interval.sql.out
index 259cb2bff5ef..52b02dae1910 100644
---
a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/interval.sql.out
+++
b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/interval.sql.out
@@ -1721,7 +1721,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -1745,7 +1745,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -1769,7 +1769,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + (- INTERVAL '3' DAY)\""
},
"queryContext" : [ {
@@ -1815,7 +1815,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + (- INTERVAL '02' SECOND)\""
},
"queryContext" : [ {
@@ -1861,7 +1861,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/try_arithmetic.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/try_arithmetic.sql.out
index 7466fa6ac6dd..391e98ed4c42 100644
---
a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/try_arithmetic.sql.out
+++
b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/try_arithmetic.sql.out
@@ -163,7 +163,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2' YEAR\"",
"inputType" : "\"INTERVAL YEAR\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2' YEAR + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ltz-nanos.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ltz-nanos.sql.out
index f9bbaf5034fa..8582e5175301 100644
---
a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ltz-nanos.sql.out
+++
b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ltz-nanos.sql.out
@@ -577,3 +577,73 @@ SELECT map(DATE '2020-01-01', 'v') ::
map<timestamp_ltz(9), string>
SELECT named_struct('f', DATE '2020-01-01') :: struct<f: timestamp_ltz(9)>
-- !query analysis
[Analyzer test output redacted due to nondeterminism]
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' +
+ INTERVAL '2 00:03:00.000456' DAY TO SECOND
+-- !query analysis
+Project [cast(2020-01-01 19:04:05.123456789 + INTERVAL '2 00:03:00.000456' DAY
TO SECOND as timestamp_ltz(9)) AS TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789'
+ INTERVAL '2 00:03:00.000456' DAY TO SECOND#x]
++- OneRowRelation
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' -
+ INTERVAL '1 00:04:00.000321' DAY TO SECOND
+-- !query analysis
+Project [cast(2020-01-01 19:04:05.123456789 - INTERVAL '1 00:04:00.000321' DAY
TO SECOND as timestamp_ltz(9)) AS TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789'
- INTERVAL '1 00:04:00.000321' DAY TO SECOND#x]
++- OneRowRelation
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '1960-01-02 03:04:05.123456789 UTC' +
+ INTERVAL '0 00:00:00.000001' DAY TO SECOND
+-- !query analysis
+Project [cast(1960-01-01 19:04:05.123456789 + INTERVAL '0 00:00:00.000001' DAY
TO SECOND as timestamp_ltz(9)) AS TIMESTAMP_LTZ '1960-01-01 19:04:05.123456789'
+ INTERVAL '0 00:00:00.000001' DAY TO SECOND#x]
++- OneRowRelation
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + make_interval(0, 1,
0, 2, 0, 0, 0)
+-- !query analysis
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"make_interval(0, 1, 0, 2, 0, 0, 0)\"",
+ "inputType" : "\"INTERVAL\"",
+ "paramIndex" : "second",
+ "requiredType" : "\"INTERVAL DAY TO SECOND\"",
+ "sqlExpr" : "\"TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789' +
make_interval(0, 1, 0, 2, 0, 0, 0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 93,
+ "fragment" : "TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' +
make_interval(0, 1, 0, 2, 0, 0, 0)"
+ } ]
+}
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + INTERVAL '1' MONTH
+-- !query analysis
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"TIMESTAMP_LTZ(9)\"",
+ "right" : "\"INTERVAL MONTH\"",
+ "sqlExpr" : "\"(TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789' + INTERVAL
'1' MONTH)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 77,
+ "fragment" : "TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + INTERVAL
'1' MONTH"
+ } ]
+}
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ntz-nanos.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ntz-nanos.sql.out
index ee11cf91b897..f7bf8f3ffd94 100644
---
a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ntz-nanos.sql.out
+++
b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp-ntz-nanos.sql.out
@@ -507,3 +507,70 @@ SELECT map(DATE '2020-01-01', 'v') ::
map<timestamp_ntz(9), string>
SELECT named_struct('f', DATE '2020-01-01') :: struct<f: timestamp_ntz(9)>
-- !query analysis
[Analyzer test output redacted due to nondeterminism]
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '2
00:03:00.000456' DAY TO SECOND
+-- !query analysis
+Project [cast(2020-01-02 03:04:05.123456789 + INTERVAL '2 00:03:00.000456' DAY
TO SECOND as timestamp_ntz(9)) AS TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789'
+ INTERVAL '2 00:03:00.000456' DAY TO SECOND#x]
++- OneRowRelation
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' - INTERVAL '1
00:04:00.000321' DAY TO SECOND
+-- !query analysis
+Project [cast(2020-01-02 03:04:05.123456789 - INTERVAL '1 00:04:00.000321' DAY
TO SECOND as timestamp_ntz(9)) AS TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789'
- INTERVAL '1 00:04:00.000321' DAY TO SECOND#x]
++- OneRowRelation
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '1960-01-02 03:04:05.123456789' + INTERVAL '0
00:00:00.000001' DAY TO SECOND
+-- !query analysis
+Project [cast(1960-01-02 03:04:05.123456789 + INTERVAL '0 00:00:00.000001' DAY
TO SECOND as timestamp_ntz(9)) AS TIMESTAMP_NTZ '1960-01-02 03:04:05.123456789'
+ INTERVAL '0 00:00:00.000001' DAY TO SECOND#x]
++- OneRowRelation
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + make_interval(0, 1, 0,
2, 0, 0, 0)
+-- !query analysis
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"make_interval(0, 1, 0, 2, 0, 0, 0)\"",
+ "inputType" : "\"INTERVAL\"",
+ "paramIndex" : "second",
+ "requiredType" : "\"INTERVAL DAY TO SECOND\"",
+ "sqlExpr" : "\"TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' +
make_interval(0, 1, 0, 2, 0, 0, 0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 89,
+ "fragment" : "TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' +
make_interval(0, 1, 0, 2, 0, 0, 0)"
+ } ]
+}
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '1' MONTH
+-- !query analysis
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"TIMESTAMP_NTZ(9)\"",
+ "right" : "\"INTERVAL MONTH\"",
+ "sqlExpr" : "\"(TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL
'1' MONTH)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 73,
+ "fragment" : "TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '1'
MONTH"
+ } ]
+}
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/try_arithmetic.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/try_arithmetic.sql.out
index 536aae7a1d9b..942a2a131790 100644
---
a/sql/core/src/test/resources/sql-tests/analyzer-results/try_arithmetic.sql.out
+++
b/sql/core/src/test/resources/sql-tests/analyzer-results/try_arithmetic.sql.out
@@ -163,7 +163,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2' YEAR\"",
"inputType" : "\"INTERVAL YEAR\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2' YEAR + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/analyzer-results/typeCoercion/native/dateTimeOperations.sql.out
b/sql/core/src/test/resources/sql-tests/analyzer-results/typeCoercion/native/dateTimeOperations.sql.out
index c2787e581688..3277ff0acd94 100644
---
a/sql/core/src/test/resources/sql-tests/analyzer-results/typeCoercion/native/dateTimeOperations.sql.out
+++
b/sql/core/src/test/resources/sql-tests/analyzer-results/typeCoercion/native/dateTimeOperations.sql.out
@@ -18,7 +18,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS TINYINT)\"",
"inputType" : "\"TINYINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS TINYINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -42,7 +42,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS SMALLINT)\"",
"inputType" : "\"SMALLINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS SMALLINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -66,7 +66,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS INT)\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS INT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -90,7 +90,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BIGINT)\"",
"inputType" : "\"BIGINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BIGINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -114,7 +114,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS FLOAT)\"",
"inputType" : "\"FLOAT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS FLOAT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -138,7 +138,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DOUBLE)\"",
"inputType" : "\"DOUBLE\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DOUBLE) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -162,7 +162,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DECIMAL(10,0))\"",
"inputType" : "\"DECIMAL(10,0)\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DECIMAL(10,0)) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -200,7 +200,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BINARY)\"",
"inputType" : "\"BINARY\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BINARY) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -224,7 +224,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BOOLEAN)\"",
"inputType" : "\"BOOLEAN\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BOOLEAN) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -262,7 +262,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS TINYINT)\"",
"inputType" : "\"TINYINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS TINYINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -286,7 +286,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS SMALLINT)\"",
"inputType" : "\"SMALLINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS SMALLINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -310,7 +310,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS INT)\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS INT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -334,7 +334,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BIGINT)\"",
"inputType" : "\"BIGINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BIGINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -358,7 +358,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS FLOAT)\"",
"inputType" : "\"FLOAT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS FLOAT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -382,7 +382,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DOUBLE)\"",
"inputType" : "\"DOUBLE\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DOUBLE) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -406,7 +406,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DECIMAL(10,0))\"",
"inputType" : "\"DECIMAL(10,0)\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DECIMAL(10,0)) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -444,7 +444,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BINARY)\"",
"inputType" : "\"BINARY\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BINARY) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -468,7 +468,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BOOLEAN)\"",
"inputType" : "\"BOOLEAN\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BOOLEAN) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -506,7 +506,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS TINYINT)\"",
"inputType" : "\"TINYINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS TINYINT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -530,7 +530,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS SMALLINT)\"",
"inputType" : "\"SMALLINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS SMALLINT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -554,7 +554,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS INT)\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS INT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -578,7 +578,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BIGINT)\"",
"inputType" : "\"BIGINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BIGINT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -602,7 +602,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS FLOAT)\"",
"inputType" : "\"FLOAT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS FLOAT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -626,7 +626,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DOUBLE)\"",
"inputType" : "\"DOUBLE\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DOUBLE) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -650,7 +650,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DECIMAL(10,0))\"",
"inputType" : "\"DECIMAL(10,0)\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DECIMAL(10,0)) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -688,7 +688,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BINARY)\"",
"inputType" : "\"BINARY\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BINARY) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -712,7 +712,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BOOLEAN)\"",
"inputType" : "\"BOOLEAN\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BOOLEAN) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/inputs/timestamp-ltz-nanos.sql
b/sql/core/src/test/resources/sql-tests/inputs/timestamp-ltz-nanos.sql
index 354d491c955c..7e8ab11f633f 100644
--- a/sql/core/src/test/resources/sql-tests/inputs/timestamp-ltz-nanos.sql
+++ b/sql/core/src/test/resources/sql-tests/inputs/timestamp-ltz-nanos.sql
@@ -160,3 +160,16 @@ SELECT array(DATE '2020-01-01') :: array<timestamp_ltz(9)>;
SELECT map('k', TIMESTAMP_LTZ '2020-01-01 12:30:15.123456789') :: map<string,
date>;
SELECT map(DATE '2020-01-01', 'v') :: map<timestamp_ltz(9), string>;
SELECT named_struct('f', DATE '2020-01-01') :: struct<f: timestamp_ltz(9)>;
+
+-- SPARK-57501: TIMESTAMP_LTZ(p) +/- ANSI day-time interval preserves nanos
remainder.
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' +
+ INTERVAL '2 00:03:00.000456' DAY TO SECOND;
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' -
+ INTERVAL '1 00:04:00.000321' DAY TO SECOND;
+SELECT TIMESTAMP_LTZ '1960-01-02 03:04:05.123456789 UTC' +
+ INTERVAL '0 00:00:00.000001' DAY TO SECOND;
+-- SPARK-57501: nanos timestamps support only ANSI day-time intervals. A
(legacy) calendar interval
+-- is rejected by TimestampAddInterval's type check, and a year-month interval
has no supported
+-- operator overload.
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + make_interval(0, 1,
0, 2, 0, 0, 0);
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + INTERVAL '1' MONTH;
diff --git
a/sql/core/src/test/resources/sql-tests/inputs/timestamp-ntz-nanos.sql
b/sql/core/src/test/resources/sql-tests/inputs/timestamp-ntz-nanos.sql
index 847a6d3607e1..0568f671e4bf 100644
--- a/sql/core/src/test/resources/sql-tests/inputs/timestamp-ntz-nanos.sql
+++ b/sql/core/src/test/resources/sql-tests/inputs/timestamp-ntz-nanos.sql
@@ -139,3 +139,13 @@ SELECT array(DATE '2020-01-01') :: array<timestamp_ntz(9)>;
SELECT map('k', TIMESTAMP_NTZ '2020-01-01 12:30:15.123456789') :: map<string,
date>;
SELECT map(DATE '2020-01-01', 'v') :: map<timestamp_ntz(9), string>;
SELECT named_struct('f', DATE '2020-01-01') :: struct<f: timestamp_ntz(9)>;
+
+-- SPARK-57501: TIMESTAMP_NTZ(p) +/- ANSI day-time interval preserves nanos
remainder.
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '2
00:03:00.000456' DAY TO SECOND;
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' - INTERVAL '1
00:04:00.000321' DAY TO SECOND;
+SELECT TIMESTAMP_NTZ '1960-01-02 03:04:05.123456789' + INTERVAL '0
00:00:00.000001' DAY TO SECOND;
+-- SPARK-57501: nanos timestamps support only ANSI day-time intervals. A
(legacy) calendar interval
+-- is rejected by TimestampAddInterval's type check, and a year-month interval
has no supported
+-- operator overload.
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + make_interval(0, 1, 0,
2, 0, 0, 0);
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '1' MONTH;
diff --git a/sql/core/src/test/resources/sql-tests/results/interval.sql.out
b/sql/core/src/test/resources/sql-tests/results/interval.sql.out
index 79fce5906df8..99be15155ce2 100644
--- a/sql/core/src/test/resources/sql-tests/results/interval.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/interval.sql.out
@@ -2168,7 +2168,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -2194,7 +2194,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -2220,7 +2220,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + (- INTERVAL '3' DAY)\""
},
"queryContext" : [ {
@@ -2270,7 +2270,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + (- INTERVAL '02' SECOND)\""
},
"queryContext" : [ {
@@ -2320,7 +2320,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/results/nonansi/interval.sql.out
b/sql/core/src/test/resources/sql-tests/results/nonansi/interval.sql.out
index e40053d1bc79..0e25cd3045b5 100644
--- a/sql/core/src/test/resources/sql-tests/results/nonansi/interval.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/nonansi/interval.sql.out
@@ -1981,7 +1981,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -2007,7 +2007,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + INTERVAL '3' DAY\""
},
"queryContext" : [ {
@@ -2033,7 +2033,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2-2' YEAR TO MONTH\"",
"inputType" : "\"INTERVAL YEAR TO MONTH\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2-2' YEAR TO MONTH + (- INTERVAL '3' DAY)\""
},
"queryContext" : [ {
@@ -2083,7 +2083,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + (- INTERVAL '02' SECOND)\""
},
"queryContext" : [ {
@@ -2133,7 +2133,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"1\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"1 + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/results/nonansi/try_arithmetic.sql.out
b/sql/core/src/test/resources/sql-tests/results/nonansi/try_arithmetic.sql.out
index ba49909bd146..a97dfcdcf793 100644
---
a/sql/core/src/test/resources/sql-tests/results/nonansi/try_arithmetic.sql.out
+++
b/sql/core/src/test/resources/sql-tests/results/nonansi/try_arithmetic.sql.out
@@ -196,7 +196,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2' YEAR\"",
"inputType" : "\"INTERVAL YEAR\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2' YEAR + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/results/timestamp-ltz-nanos.sql.out
b/sql/core/src/test/resources/sql-tests/results/timestamp-ltz-nanos.sql.out
index 4b1f02b792d1..7850cfc9bfef 100644
--- a/sql/core/src/test/resources/sql-tests/results/timestamp-ltz-nanos.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/timestamp-ltz-nanos.sql.out
@@ -649,3 +649,80 @@ SELECT named_struct('f', DATE '2020-01-01') :: struct<f:
timestamp_ltz(9)>
struct<named_struct(f, DATE '2020-01-01'):struct<f:timestamp_ltz(9)>>
-- !query output
{"f":2020-01-01 00:00:00}
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' +
+ INTERVAL '2 00:03:00.000456' DAY TO SECOND
+-- !query schema
+struct<TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789' + INTERVAL '2
00:03:00.000456' DAY TO SECOND:timestamp_ltz(9)>
+-- !query output
+2020-01-03 19:07:05.123912789
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' -
+ INTERVAL '1 00:04:00.000321' DAY TO SECOND
+-- !query schema
+struct<TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789' - INTERVAL '1
00:04:00.000321' DAY TO SECOND:timestamp_ltz(9)>
+-- !query output
+2019-12-31 19:00:05.123135789
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '1960-01-02 03:04:05.123456789 UTC' +
+ INTERVAL '0 00:00:00.000001' DAY TO SECOND
+-- !query schema
+struct<TIMESTAMP_LTZ '1960-01-01 19:04:05.123456789' + INTERVAL '0
00:00:00.000001' DAY TO SECOND:timestamp_ltz(9)>
+-- !query output
+1960-01-01 19:04:05.123457789
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + make_interval(0, 1,
0, 2, 0, 0, 0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"make_interval(0, 1, 0, 2, 0, 0, 0)\"",
+ "inputType" : "\"INTERVAL\"",
+ "paramIndex" : "second",
+ "requiredType" : "\"INTERVAL DAY TO SECOND\"",
+ "sqlExpr" : "\"TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789' +
make_interval(0, 1, 0, 2, 0, 0, 0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 93,
+ "fragment" : "TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' +
make_interval(0, 1, 0, 2, 0, 0, 0)"
+ } ]
+}
+
+
+-- !query
+SELECT TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + INTERVAL '1' MONTH
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"TIMESTAMP_LTZ(9)\"",
+ "right" : "\"INTERVAL MONTH\"",
+ "sqlExpr" : "\"(TIMESTAMP_LTZ '2020-01-01 19:04:05.123456789' + INTERVAL
'1' MONTH)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 77,
+ "fragment" : "TIMESTAMP_LTZ '2020-01-02 03:04:05.123456789 UTC' + INTERVAL
'1' MONTH"
+ } ]
+}
diff --git
a/sql/core/src/test/resources/sql-tests/results/timestamp-ntz-nanos.sql.out
b/sql/core/src/test/resources/sql-tests/results/timestamp-ntz-nanos.sql.out
index ee134ef9ce69..9f64ed3b229f 100644
--- a/sql/core/src/test/resources/sql-tests/results/timestamp-ntz-nanos.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/timestamp-ntz-nanos.sql.out
@@ -570,3 +570,77 @@ SELECT named_struct('f', DATE '2020-01-01') :: struct<f:
timestamp_ntz(9)>
struct<named_struct(f, DATE '2020-01-01'):struct<f:timestamp_ntz(9)>>
-- !query output
{"f":2020-01-01 00:00:00}
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '2
00:03:00.000456' DAY TO SECOND
+-- !query schema
+struct<TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '2
00:03:00.000456' DAY TO SECOND:timestamp_ntz(9)>
+-- !query output
+2020-01-04 03:07:05.123912789
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' - INTERVAL '1
00:04:00.000321' DAY TO SECOND
+-- !query schema
+struct<TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' - INTERVAL '1
00:04:00.000321' DAY TO SECOND:timestamp_ntz(9)>
+-- !query output
+2020-01-01 03:00:05.123135789
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '1960-01-02 03:04:05.123456789' + INTERVAL '0
00:00:00.000001' DAY TO SECOND
+-- !query schema
+struct<TIMESTAMP_NTZ '1960-01-02 03:04:05.123456789' + INTERVAL '0
00:00:00.000001' DAY TO SECOND:timestamp_ntz(9)>
+-- !query output
+1960-01-02 03:04:05.123457789
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + make_interval(0, 1, 0,
2, 0, 0, 0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"make_interval(0, 1, 0, 2, 0, 0, 0)\"",
+ "inputType" : "\"INTERVAL\"",
+ "paramIndex" : "second",
+ "requiredType" : "\"INTERVAL DAY TO SECOND\"",
+ "sqlExpr" : "\"TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' +
make_interval(0, 1, 0, 2, 0, 0, 0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 89,
+ "fragment" : "TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' +
make_interval(0, 1, 0, 2, 0, 0, 0)"
+ } ]
+}
+
+
+-- !query
+SELECT TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '1' MONTH
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"TIMESTAMP_NTZ(9)\"",
+ "right" : "\"INTERVAL MONTH\"",
+ "sqlExpr" : "\"(TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL
'1' MONTH)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 73,
+ "fragment" : "TIMESTAMP_NTZ '2020-01-02 03:04:05.123456789' + INTERVAL '1'
MONTH"
+ } ]
+}
diff --git
a/sql/core/src/test/resources/sql-tests/results/try_arithmetic.sql.out
b/sql/core/src/test/resources/sql-tests/results/try_arithmetic.sql.out
index 266af5a4fe34..9e6725d016c9 100644
--- a/sql/core/src/test/resources/sql-tests/results/try_arithmetic.sql.out
+++ b/sql/core/src/test/resources/sql-tests/results/try_arithmetic.sql.out
@@ -242,7 +242,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"INTERVAL '2' YEAR\"",
"inputType" : "\"INTERVAL YEAR\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"INTERVAL '2' YEAR + INTERVAL '02' SECOND\""
},
"queryContext" : [ {
diff --git
a/sql/core/src/test/resources/sql-tests/results/typeCoercion/native/dateTimeOperations.sql.out
b/sql/core/src/test/resources/sql-tests/results/typeCoercion/native/dateTimeOperations.sql.out
index 10cceabca052..ad8ca4688962 100644
---
a/sql/core/src/test/resources/sql-tests/results/typeCoercion/native/dateTimeOperations.sql.out
+++
b/sql/core/src/test/resources/sql-tests/results/typeCoercion/native/dateTimeOperations.sql.out
@@ -20,7 +20,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS TINYINT)\"",
"inputType" : "\"TINYINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS TINYINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -46,7 +46,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS SMALLINT)\"",
"inputType" : "\"SMALLINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS SMALLINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -72,7 +72,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS INT)\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS INT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -98,7 +98,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BIGINT)\"",
"inputType" : "\"BIGINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BIGINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -124,7 +124,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS FLOAT)\"",
"inputType" : "\"FLOAT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS FLOAT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -150,7 +150,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DOUBLE)\"",
"inputType" : "\"DOUBLE\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DOUBLE) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -176,7 +176,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DECIMAL(10,0))\"",
"inputType" : "\"DECIMAL(10,0)\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DECIMAL(10,0)) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -218,7 +218,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BINARY)\"",
"inputType" : "\"BINARY\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BINARY) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -244,7 +244,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BOOLEAN)\"",
"inputType" : "\"BOOLEAN\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BOOLEAN) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -286,7 +286,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS TINYINT)\"",
"inputType" : "\"TINYINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS TINYINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -312,7 +312,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS SMALLINT)\"",
"inputType" : "\"SMALLINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS SMALLINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -338,7 +338,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS INT)\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS INT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -364,7 +364,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BIGINT)\"",
"inputType" : "\"BIGINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BIGINT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -390,7 +390,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS FLOAT)\"",
"inputType" : "\"FLOAT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS FLOAT) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -416,7 +416,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DOUBLE)\"",
"inputType" : "\"DOUBLE\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DOUBLE) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -442,7 +442,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DECIMAL(10,0))\"",
"inputType" : "\"DECIMAL(10,0)\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DECIMAL(10,0)) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -484,7 +484,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BINARY)\"",
"inputType" : "\"BINARY\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BINARY) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -510,7 +510,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BOOLEAN)\"",
"inputType" : "\"BOOLEAN\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BOOLEAN) + INTERVAL '2' DAY\""
},
"queryContext" : [ {
@@ -552,7 +552,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS TINYINT)\"",
"inputType" : "\"TINYINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS TINYINT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -578,7 +578,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS SMALLINT)\"",
"inputType" : "\"SMALLINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS SMALLINT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -604,7 +604,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS INT)\"",
"inputType" : "\"INT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS INT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -630,7 +630,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BIGINT)\"",
"inputType" : "\"BIGINT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BIGINT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -656,7 +656,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS FLOAT)\"",
"inputType" : "\"FLOAT\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS FLOAT) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -682,7 +682,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DOUBLE)\"",
"inputType" : "\"DOUBLE\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DOUBLE) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -708,7 +708,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS DECIMAL(10,0))\"",
"inputType" : "\"DECIMAL(10,0)\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS DECIMAL(10,0)) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -750,7 +750,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BINARY)\"",
"inputType" : "\"BINARY\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BINARY) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
@@ -776,7 +776,7 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException
"inputSql" : "\"CAST(1 AS BOOLEAN)\"",
"inputType" : "\"BOOLEAN\"",
"paramIndex" : "first",
- "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "requiredType" : "(\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\" or
\"(TIMESTAMP_LTZ(P) OR TIMESTAMP_NTZ(P) WITH P IN [7, 9])\")",
"sqlExpr" : "\"CAST(1 AS BOOLEAN) + (- INTERVAL '2' DAY)\""
},
"queryContext" : [ {
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
