From 29d850d25c8bba7b743dc2f20ceba9f7c94bd4dc Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Fri, 18 Jul 2025 02:01:43 +0200 Subject: [PATCH 1/9] Initial commit --- .../org/apache/spark/sql/functions.scala | 23 ++ .../catalyst/analysis/FunctionRegistry.scala | 2 +- .../expressions/datetimeExpressions.scala | 146 ++++++++++++ .../sql/catalyst/util/DateTimeUtils.scala | 28 +++ .../expressions/DateExpressionsSuite.scala | 123 +++++++++- .../catalyst/util/DateTimeUtilsSuite.scala | 54 +++++ .../nonansi/timestamp.sql.out | 182 +++++++++++++++ .../analyzer-results/timestamp.sql.out | 182 +++++++++++++++ .../timestampNTZ/timestamp.sql.out | 182 +++++++++++++++ .../resources/sql-tests/inputs/timestamp.sql | 22 ++ .../results/nonansi/timestamp.sql.out | 212 ++++++++++++++++++ .../sql-tests/results/timestamp.sql.out | 212 ++++++++++++++++++ .../results/timestampNTZ/timestamp.sql.out | 212 ++++++++++++++++++ .../apache/spark/sql/DateFunctionsSuite.scala | 37 +++ 14 files changed, 1611 insertions(+), 6 deletions(-) diff --git a/sql/api/src/main/scala/org/apache/spark/sql/functions.scala b/sql/api/src/main/scala/org/apache/spark/sql/functions.scala index ce5c76807b5c1..da216cb0a3f39 100644 --- a/sql/api/src/main/scala/org/apache/spark/sql/functions.scala +++ b/sql/api/src/main/scala/org/apache/spark/sql/functions.scala @@ -8344,6 +8344,29 @@ object functions { secs: Column): Column = Column.fn("make_timestamp", years, months, days, hours, mins, secs) + /** + * Create timestamp from date and time fields. The result data type is consistent with the value + * of configuration `spark.sql.timestampType`. If the configuration `spark.sql.ansi.enabled` is + * false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. + * + * @group datetime_funcs + * @since 4.0.0 + */ + def make_timestamp(date: Column, time: Column): Column = + Column.fn("make_timestamp", date, time) + + /** + * Create timestamp from date, time and timezone fields. The result data type is consistent with + * the value of configuration `spark.sql.timestampType`. If the configuration + * `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it + * will throw an error instead. + * + * @group datetime_funcs + * @since 4.0.0 + */ + def make_timestamp(date: Column, time: Column, timezone: Column): Column = + Column.fn("make_timestamp", date, time, timezone) + /** * Try to create a timestamp from years, months, days, hours, mins, secs and timezone fields. * The result data type is consistent with the value of configuration `spark.sql.timestampType`. diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala index 76c3b1d80b294..2baf71153d748 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/FunctionRegistry.scala @@ -674,7 +674,7 @@ object FunctionRegistry { expression[WindowTime]("window_time"), expression[MakeDate]("make_date"), expression[MakeTime]("make_time"), - expression[MakeTimestamp]("make_timestamp"), + expressionBuilder("make_timestamp", MakeTimestampExpressionBuilder), expression[TryMakeTimestamp]("try_make_timestamp"), expression[MonthName]("monthname"), // We keep the 2 expression builders below to have different function docs. 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 2f937f5fbf46d..3bd8dff4765fa 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 @@ -2791,6 +2791,10 @@ object TryMakeTimestampLTZExpressionBuilder extends ExpressionBuilder { } } +/** + * This make_timestamp overload creates a timestamp from: + * - a year, month, day, hour, min, sec and optional timezone. + */ // scalastyle:off line.size.limit @ExpressionDescription( usage = "_FUNC_(year, month, day, hour, min, sec[, timezone]) - Create timestamp from year, month, day, hour, min, sec and timezone fields. The result data type is consistent with the value of configuration `spark.sql.timestampType`. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead.", @@ -3077,6 +3081,148 @@ case class TryMakeTimestamp( } } +/** + * This make_timestamp overload creates a timestamp from: + * - a date, optional time, and optional timezone. + */ +// scalastyle:off line.size.limit +@ExpressionDescription( + usage = """ + _FUNC_(date [, time [, timezone]]) - Create timestamp from date and time fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. + """, + arguments = """ + Arguments: + * date - a date expression + * time - a time expression + * timezone - the time zone identifier. For example, CET, UTC and etc. + """, + examples = """ + Examples: + > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); + 2014-12-28 06:30:45.887 + > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); + 2014-12-28 06:30:45.887 + """, + group = "datetime_funcs", + since = "4.1.0") +// scalastyle:on line.size.limit +case class MakeTimestampFromDateTime( + date: Expression, + time: Expression, + timezone: Option[Expression] = None) + extends Expression with RuntimeReplaceable with ExpectsInputTypes { + + def this(date: Expression, time: Expression) = + this(date, time, None) + def this(date: Expression, time: Expression, timezone: Expression) = + this(date, time, Some(timezone)) + + override def children: Seq[Expression] = Seq(date, time) ++ timezone + + override def inputTypes: Seq[AbstractDataType] = Seq(DateType, AnyTimeType) ++ + timezone.map(_ => StringTypeWithCollation(supportsTrimCollation = true)) + + override def replacement: Expression = timezone match { + case Some(tz) => + StaticInvoke( + classOf[DateTimeUtils.type], + TimestampType, + "makeTimestamp", + Seq(date, time, tz), + Seq(date.dataType, time.dataType, tz.dataType), + returnNullable = children.exists(_.nullable)) + case None => + val defaultZoneIdExpr = Literal("+00:00") + StaticInvoke( + classOf[DateTimeUtils.type], + TimestampType, + "makeTimestamp", + Seq(date, time, defaultZoneIdExpr), + Seq(date.dataType, time.dataType, defaultZoneIdExpr.dataType), + returnNullable = children.exists(_.nullable)) + } + + override def prettyName: String = "make_timestamp" + + override protected def withNewChildrenInternal( + newChildren: IndexedSeq[Expression]): Expression = { + val timezoneOpt = if (timezone.isDefined) Some(newChildren(2)) else None + copy(date = newChildren(0), time = newChildren(1), timezone = timezoneOpt) + } +} + +/** + * This make_timestamp expression builder creates a timestamp from: + * - a year, month, day, hour, min, sec and optional timezone, or + * - a date, optional time, and optional timezone. + */ +// scalastyle:off line.size.limit +@ExpressionDescription( + usage = """ + _FUNC_(year, month, day, hour, min, sec[, timezone]) - Create the current timestamp with local time zone from year, month, day, hour, min, sec and timezone fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. + + _FUNC_(date [, time [, timezone]]) - Create timestamp from date and time fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. + """, + arguments = """ + Arguments: + * year - the year to represent, from 1 to 9999 + * month - the month-of-year to represent, from 1 (January) to 12 (December) + * day - the day-of-month to represent, from 1 to 31 + * hour - the hour-of-day to represent, from 0 to 23 + * min - the minute-of-hour to represent, from 0 to 59 + * sec - the second-of-minute and its micro-fraction to represent, from + 0 to 60. If the sec argument equals to 60, the seconds field is set + to 0 and 1 minute is added to the final timestamp. + * date - a date expression + * time - a time expression + * timezone - the time zone identifier. For example, CET, UTC and etc. + """, + examples = """ + Examples: + > SELECT _FUNC_(2014, 12, 28, 6, 30, 45.887); + 2014-12-28 06:30:45.887 + > SELECT _FUNC_(2014, 12, 28, 6, 30, 45.887, 'CET'); + 2014-12-27 21:30:45.887 + > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); + 2014-12-28 06:30:45.887 + > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); + 2014-12-28 06:30:45.887 + """, + group = "datetime_funcs", + since = "4.1.0") +// scalastyle:on line.size.limit +object MakeTimestampExpressionBuilder extends ExpressionBuilder { + override def build(funcName: String, expressions: Seq[Expression]): Expression = { + val numArgs = expressions.length + if (numArgs == 2) { + MakeTimestampFromDateTime(expressions(0), expressions(1)) + } else if (numArgs == 3 && expressions(0).dataType == DateType) { + // This is date, time, timezone + MakeTimestampFromDateTime(expressions(0), expressions(1), Some(expressions(2))) + } else if (numArgs == 6) { + MakeTimestamp( + expressions(0), + expressions(1), + expressions(2), + expressions(3), + expressions(4), + expressions(5)) + } else if (numArgs == 7) { + MakeTimestamp( + expressions(0), + expressions(1), + expressions(2), + expressions(3), + expressions(4), + expressions(5), + Some(expressions(6)) + ) + } else { + throw QueryCompilationErrors.wrongNumArgsError(funcName, Seq(2, 3, 6, 7), numArgs) + } + } +} + object DatePart { def parseExtractField( 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 5037f304d1846..e60dc3976ed9c 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 @@ -848,6 +848,34 @@ object DateTimeUtils extends SparkDateTimeUtils { localDateTimeToMicros(LocalDateTime.of(daysToLocalDate(days), nanosToLocalTime(nanos))) } + /** + * Makes a timestamp from a date and a local time. + * + * @param days The number of days since the epoch. 1970-01-01. + * Negative numbers represent earlier days. + * @param nanos The number of nanoseconds within the day since the midnight. + * @param zoneId The time zone ID at which the operation is performed. + * @return The number of microseconds since the epoch of 1970-01-01 00:00:00Z. + */ + def makeTimestamp(days: Int, nanos: Long, zoneId: ZoneId): Long = { + val ldt = LocalDateTime.of(daysToLocalDate(days), nanosToLocalTime(nanos)) + instantToMicros(ldt.atZone(zoneId).toInstant) + } + + /** + * Makes a timestamp from a date and a local time with timezone string. + * + * @param days The number of days since the epoch. 1970-01-01. + * Negative numbers represent earlier days. + * @param nanos The number of nanoseconds within the day since the midnight. + * @param timezone The time zone string. + * @return The number of microseconds since the epoch of 1970-01-01 00:00:00Z. + */ + def makeTimestamp(days: Int, nanos: Long, timezone: UTF8String): Long = { + val zoneId = getZoneId(timezone.toString) + makeTimestamp(days, nanos, zoneId) + } + /** * Adds a day-time interval to a time. * 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 02edd36952702..e44e9c8e35e9a 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 @@ -2142,14 +2142,127 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { } } - test("make timestamp_ntz from date and time") { - def dateLit(d: String): Expression = Literal(LocalDate.parse(d)) - def timeLit(t: String): Expression = Literal(LocalTime.parse(t)) - def tsNtz(s: String): Long = localDateTimeToMicros(LocalDateTime.parse(s), UTC) + /** + * Helper method to create a DATE literal from a string in date format. + */ + private def dateLit(date: String): Expression = Literal(LocalDate.parse(date)) + + /** + * Helper method to create a TIME literal from a string in time format. + */ + private def timeLit(time: String): Expression = Literal(LocalTime.parse(time)) + + /** + * Helper method to get the microseconds from a timestamp represented as a string. + */ + private def timestampToMicros(timestamp: String, zoneId: ZoneId): Long = { + localDateTimeToMicros(LocalDateTime.parse(timestamp), zoneId) + } + + test("SPARK-51415: make timestamp from date and time") { + // Test with valid date and time. + checkEvaluation( + MakeTimestampFromDateTime(dateLit("2023-10-01"), timeLit("12:34:56.123456")), + timestampToMicros("2023-10-01T12:34:56.123456", UTC) + ) + + // Test with null date. + checkEvaluation( + MakeTimestampFromDateTime(Literal(null, DateType), timeLit("12:34:56.123456")), + null + ) + // Test with null time. + checkEvaluation( + MakeTimestampFromDateTime(dateLit("2023-10-01"), Literal(null, TimeType())), + null + ) + + // Test with both date and time as null. + checkEvaluation( + MakeTimestampFromDateTime(Literal(null, DateType), Literal(null, TimeType())), + null + ) + } + + test("SPARK-51415: make timestamp from date, time, and timezone") { + // Test with valid date, time, and timezone. + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + timeLit("12:34:56.123456"), + Some(Literal("-09:30")) + ), + timestampToMicros("2023-10-01T12:34:56.123456", MIT) + ) + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + timeLit("12:34:56.123456"), + Some(Literal("-08:00")) + ), + timestampToMicros("2023-10-01T12:34:56.123456", PST) + ) + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + timeLit("12:34:56.123456"), + Some(Literal("+00:00")) + ), + timestampToMicros("2023-10-01T12:34:56.123456", UTC) + ) + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + timeLit("12:34:56.123456"), + Some(Literal("+01:00")) + ), + timestampToMicros("2023-10-01T12:34:56.123456", CET) + ) + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + timeLit("12:34:56.123456"), + Some(Literal("+09:00")) + ), + timestampToMicros("2023-10-01T12:34:56.123456", JST) + ) + + // Test with null date. + checkEvaluation( + MakeTimestampFromDateTime( + Literal(null, DateType), + timeLit("12:34:56.123456"), + Some(Literal("+00:00")) + ), + null + ) + + // Test with null time. + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + Literal(null, TimeType()), + Some(Literal("+00:00")) + ), + null + ) + + // Test with both date and time as null. + checkEvaluation( + MakeTimestampFromDateTime( + Literal(null, DateType), + Literal(null, TimeType()), + Some(Literal("+00:00")) + ), + null + ) + } + + test("make timestamp_ntz from date and time") { checkEvaluation(MakeTimestampNTZ(dateLit("1970-01-01"), timeLit("00:00:00")), 0L) checkEvaluation(MakeTimestampNTZ(dateLit("2025-06-20"), timeLit("15:20:30.123456")), - tsNtz("2025-06-20T15:20:30.123456")) + timestampToMicros("2025-06-20T15:20:30.123456", UTC)) checkEvaluation(MakeTimestampNTZ(Literal(null, DateType), timeLit("15:20:30.123456")), null) checkEvaluation(MakeTimestampNTZ(dateLit("2025-06-20"), Literal(null, TimeType())), 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 2af3111070272..4537277ea6d0f 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 @@ -1220,6 +1220,60 @@ class DateTimeUtilsSuite extends SparkFunSuite with Matchers with SQLHelper { } } + test("SPARK-51415: makeTimestamp with days, nanos, and zoneId") { + Seq( + (MIT, -34200000000L), // -09:30 + (PST, -28800000000L), // -08:00 + (UTC, 0L), // +00:00 + (CET, 3600000000L), // +01:00 + (JST, 32400000000L) // +09:00 + ).foreach({ case (zoneId: ZoneId, microsOffset: Long) => + assert(makeTimestamp(0, 0, zoneId) == + 0 - microsOffset) + assert(makeTimestamp(0, localTime(23, 59, 59), zoneId) * NANOS_PER_MICROS == + localTime(23, 59, 59) - microsOffset * NANOS_PER_MICROS) + assert(makeTimestamp(-1, 0, zoneId) == + -1 * MICROS_PER_DAY - microsOffset) + assert(makeTimestamp(-1, localTime(23, 59, 59, 999999), zoneId) == + -1 - microsOffset) + assert(makeTimestamp(days(9999, 12, 31), localTime(23, 59, 59, 999999), zoneId) == + date(9999, 12, 31, 23, 59, 59, 999999) - microsOffset) + assert(makeTimestamp(days(1, 1, 1), localTime(0, 0, 0), zoneId) == + date(1, 1, 1, 0, 0, 0) - microsOffset) + val msg = intercept[DateTimeException] { + makeTimestamp(0, -1, zoneId) + }.getMessage + assert(msg.contains("Invalid value")) + }) + } + + test("SPARK-51415: makeTimestamp with days, nanos, and timezone") { + Seq( + (UTF8String.fromString("-09:30"), -34200000000L), // MIT + (UTF8String.fromString("-08:00"), -28800000000L), // PST + (UTF8String.fromString("+00:00"), 0L), // UTC + (UTF8String.fromString("+01:00"), 3600000000L), // CET + (UTF8String.fromString("+09:00"), 32400000000L) // JST + ).foreach({ case (timezone: UTF8String, microsOffset: Long) => + assert(makeTimestamp(0, 0, timezone) == + 0 - microsOffset) + assert(makeTimestamp(0, localTime(23, 59, 59), timezone) * NANOS_PER_MICROS == + localTime(23, 59, 59) - microsOffset * NANOS_PER_MICROS) + assert(makeTimestamp(-1, 0, timezone) == + -1 * MICROS_PER_DAY - microsOffset) + assert(makeTimestamp(-1, localTime(23, 59, 59, 999999), timezone) == + -1 - microsOffset) + assert(makeTimestamp(days(9999, 12, 31), localTime(23, 59, 59, 999999), timezone) == + date(9999, 12, 31, 23, 59, 59, 999999) - microsOffset) + assert(makeTimestamp(days(1, 1, 1), localTime(0, 0, 0), timezone) == + date(1, 1, 1, 0, 0, 0) - microsOffset) + val msg = intercept[DateTimeException] { + makeTimestamp(0, -1, timezone) + }.getMessage + assert(msg.contains("Invalid value")) + }) + } + test("makeTimestampNTZ") { assert(makeTimestampNTZ(0, 0) == 0) assert(makeTimestampNTZ(0, localTime(23, 59, 59)) * NANOS_PER_MICROS == localTime(23, 59, 59)) diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out index 79f4ec139453a..8792c6e158c84 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out @@ -157,6 +157,188 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out index ba6be278efe5a..2a8395a6ee58b 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out @@ -157,6 +157,188 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out index ee88233276daa..d0c0f1848a197 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out @@ -158,6 +158,188 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql index 72ea88a0320e3..73f4c12d3245f 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql @@ -26,6 +26,28 @@ SELECT make_timestamp(1, 1, 1, 1, 1, 59.999999); SELECT make_timestamp(1, 1, 1, 1, 1, 99.999999); SELECT make_timestamp(1, 1, 1, 1, 1, 999.999999); +-- SPARK-51415: timestamp date + time constructor. +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)); +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00'); +SELECT make_timestamp(NULL, TIME'00:00:00'); +SELECT make_timestamp(DATE'1970-01-01', NULL); +SELECT make_timestamp(NULL, NULL); + +-- SPARK-51415: timestamp date + time + timezone constructor. +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT'); +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST'); +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC'); +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET'); +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST'); +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC'); +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC'); +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC'); +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL); +SELECT make_timestamp(NULL, NULL, 'UTC'); +SELECT make_timestamp(NULL, TIME'00:00:00', NULL); +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL); +SELECT make_timestamp(NULL, NULL, NULL); + -- [SPARK-31710] TIMESTAMP_SECONDS, TIMESTAMP_MILLISECONDS and TIMESTAMP_MICROSECONDS that always create timestamp_ltz select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null); select TIMESTAMP_SECONDS(1.23), TIMESTAMP_SECONDS(1.23d), TIMESTAMP_SECONDS(FLOAT(1.23)); diff --git a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out index d995063e23aff..5e457be4e1937 100644 --- a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out @@ -180,6 +180,218 @@ struct NULL +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query schema +struct +-- !query output +2021-07-10 10:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query schema +struct +-- !query output +2021-07-11 06:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query schema +struct +-- !query output +2021-07-10 21:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query schema +struct +-- !query output +2021-07-10 14:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out index 27a6b21b9c9a5..79b7f9c1f530e 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out @@ -211,6 +211,218 @@ org.apache.spark.SparkDateTimeException } +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query schema +struct +-- !query output +2021-07-10 10:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query schema +struct +-- !query output +2021-07-11 06:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query schema +struct +-- !query output +2021-07-10 21:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query schema +struct +-- !query output +2021-07-10 14:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out index 0ef7de5f8d546..961549497523f 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out @@ -180,6 +180,218 @@ struct NULL +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query schema +struct +-- !query output +2021-07-10 10:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query schema +struct +-- !query output +2021-07-11 06:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query schema +struct +-- !query output +2021-07-10 21:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query schema +struct +-- !query output +2021-07-10 14:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala index b65636dfcde07..9e924657157c5 100644 --- a/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala +++ b/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala @@ -1338,6 +1338,43 @@ class DateFunctionsSuite extends QueryTest with SharedSparkSession { checkAnswer(result3, result4) } + test("SPARK-51415: make_timestamp with date and time") { + // Test date + time overload: make_timestamp(date, time). + val dateTimeDF = Seq( + ( + "2014-12-28", + "06:30:45" + ) + ).toDF("date", "time") + + val result1 = dateTimeDF.selectExpr( + "make_timestamp(CAST(date AS DATE), CAST(time AS TIME))" + ) + val result2 = dateTimeDF.select( + make_timestamp(col("date").cast("date"), col("time").cast("time")) + ) + checkAnswer(result1, result2) + } + + test("SPARK-51415: make_timestamp with date, time, and timezone") { + // Test date + time + timezone overload: make_timestamp(date, time, timezone). + val dateTimeTimezoneDF = Seq( + ( + "2014-12-28", + "06:30:45", + "CET" + ) + ).toDF("date", "time", "timezone") + + val result1 = dateTimeTimezoneDF.selectExpr( + "make_timestamp(CAST(date AS DATE), CAST(time AS TIME), timezone)" + ) + val result2 = dateTimeTimezoneDF.select( + make_timestamp(col("date").cast("date"), col("time").cast("time"), col("timezone")) + ) + checkAnswer(result1, result2) + } + test("make_timestamp_ltz") { val df = Seq((100, 11, 1, 12, 30, 01.001001, "UTC")). toDF("year", "month", "day", "hour", "min", "sec", "timezone") From 0aad02745d2aed645c8af34b4d171154d48f4727 Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Fri, 18 Jul 2025 02:09:24 +0200 Subject: [PATCH 2/9] Update functions --- sql/api/src/main/scala/org/apache/spark/sql/functions.scala | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sql/api/src/main/scala/org/apache/spark/sql/functions.scala b/sql/api/src/main/scala/org/apache/spark/sql/functions.scala index da216cb0a3f39..1e15098524d3a 100644 --- a/sql/api/src/main/scala/org/apache/spark/sql/functions.scala +++ b/sql/api/src/main/scala/org/apache/spark/sql/functions.scala @@ -8350,7 +8350,7 @@ object functions { * false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. * * @group datetime_funcs - * @since 4.0.0 + * @since 4.1.0 */ def make_timestamp(date: Column, time: Column): Column = Column.fn("make_timestamp", date, time) @@ -8362,7 +8362,7 @@ object functions { * will throw an error instead. * * @group datetime_funcs - * @since 4.0.0 + * @since 4.1.0 */ def make_timestamp(date: Column, time: Column, timezone: Column): Column = Column.fn("make_timestamp", date, time, timezone) From 73367f1e7ca36fd23744066dce1f329dfb842a0f Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Fri, 18 Jul 2025 05:08:20 +0200 Subject: [PATCH 3/9] Update --- .../org/apache/spark/sql/functions.scala | 23 ------------ .../apache/spark/sql/DateFunctionsSuite.scala | 37 ------------------- 2 files changed, 60 deletions(-) diff --git a/sql/api/src/main/scala/org/apache/spark/sql/functions.scala b/sql/api/src/main/scala/org/apache/spark/sql/functions.scala index 1e15098524d3a..ce5c76807b5c1 100644 --- a/sql/api/src/main/scala/org/apache/spark/sql/functions.scala +++ b/sql/api/src/main/scala/org/apache/spark/sql/functions.scala @@ -8344,29 +8344,6 @@ object functions { secs: Column): Column = Column.fn("make_timestamp", years, months, days, hours, mins, secs) - /** - * Create timestamp from date and time fields. The result data type is consistent with the value - * of configuration `spark.sql.timestampType`. If the configuration `spark.sql.ansi.enabled` is - * false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. - * - * @group datetime_funcs - * @since 4.1.0 - */ - def make_timestamp(date: Column, time: Column): Column = - Column.fn("make_timestamp", date, time) - - /** - * Create timestamp from date, time and timezone fields. The result data type is consistent with - * the value of configuration `spark.sql.timestampType`. If the configuration - * `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it - * will throw an error instead. - * - * @group datetime_funcs - * @since 4.1.0 - */ - def make_timestamp(date: Column, time: Column, timezone: Column): Column = - Column.fn("make_timestamp", date, time, timezone) - /** * Try to create a timestamp from years, months, days, hours, mins, secs and timezone fields. * The result data type is consistent with the value of configuration `spark.sql.timestampType`. diff --git a/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala index 9e924657157c5..b65636dfcde07 100644 --- a/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala +++ b/sql/core/src/test/scala/org/apache/spark/sql/DateFunctionsSuite.scala @@ -1338,43 +1338,6 @@ class DateFunctionsSuite extends QueryTest with SharedSparkSession { checkAnswer(result3, result4) } - test("SPARK-51415: make_timestamp with date and time") { - // Test date + time overload: make_timestamp(date, time). - val dateTimeDF = Seq( - ( - "2014-12-28", - "06:30:45" - ) - ).toDF("date", "time") - - val result1 = dateTimeDF.selectExpr( - "make_timestamp(CAST(date AS DATE), CAST(time AS TIME))" - ) - val result2 = dateTimeDF.select( - make_timestamp(col("date").cast("date"), col("time").cast("time")) - ) - checkAnswer(result1, result2) - } - - test("SPARK-51415: make_timestamp with date, time, and timezone") { - // Test date + time + timezone overload: make_timestamp(date, time, timezone). - val dateTimeTimezoneDF = Seq( - ( - "2014-12-28", - "06:30:45", - "CET" - ) - ).toDF("date", "time", "timezone") - - val result1 = dateTimeTimezoneDF.selectExpr( - "make_timestamp(CAST(date AS DATE), CAST(time AS TIME), timezone)" - ) - val result2 = dateTimeTimezoneDF.select( - make_timestamp(col("date").cast("date"), col("time").cast("time"), col("timezone")) - ) - checkAnswer(result1, result2) - } - test("make_timestamp_ltz") { val df = Seq((100, 11, 1, 12, 30, 01.001001, "UTC")). toDF("year", "month", "day", "hour", "min", "sec", "timezone") From 176d9523d812160cd922064cce32cf26b80a1b62 Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Fri, 18 Jul 2025 11:00:24 +0200 Subject: [PATCH 4/9] Fix failures --- .../expressions/datetimeExpressions.scala | 2 +- .../expressions/DateExpressionsSuite.scala | 13 +- .../analyzer-results/datetime-legacy.sql.out | 182 +++++++++++++++ .../timestampNTZ/timestamp-ansi.sql.out | 182 +++++++++++++++ .../sql-tests/results/datetime-legacy.sql.out | 212 ++++++++++++++++++ .../timestampNTZ/timestamp-ansi.sql.out | 212 ++++++++++++++++++ 6 files changed, 798 insertions(+), 5 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 3bd8dff4765fa..c459542a52060 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 @@ -3186,7 +3186,7 @@ case class MakeTimestampFromDateTime( > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); 2014-12-28 06:30:45.887 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); - 2014-12-28 06:30:45.887 + 2014-12-27 22:30:45.887 """, group = "datetime_funcs", since = "4.1.0") 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 e44e9c8e35e9a..8291100723162 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 @@ -2171,13 +2171,11 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { MakeTimestampFromDateTime(Literal(null, DateType), timeLit("12:34:56.123456")), null ) - // Test with null time. checkEvaluation( MakeTimestampFromDateTime(dateLit("2023-10-01"), Literal(null, TimeType())), null ) - // Test with both date and time as null. checkEvaluation( MakeTimestampFromDateTime(Literal(null, DateType), Literal(null, TimeType())), @@ -2237,7 +2235,6 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { ), null ) - // Test with null time. checkEvaluation( MakeTimestampFromDateTime( @@ -2247,7 +2244,15 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { ), null ) - + // Test with null timezone. + checkEvaluation( + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + timeLit("12:34:56.123456"), + Some(Literal(null, StringType)) + ), + null + ) // Test with both date and time as null. checkEvaluation( MakeTimestampFromDateTime( diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out index 28df8ad68eed9..052bfa3edd8df 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out @@ -1113,6 +1113,188 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out index fce31671cddf2..c0b35c30526ad 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out @@ -158,6 +158,188 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query analysis +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out b/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out index ed4ce53d9dfaf..851831052a804 100644 --- a/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out @@ -1404,6 +1404,218 @@ org.apache.spark.SparkDateTimeException } +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query schema +struct +-- !query output +2021-07-10 10:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query schema +struct +-- !query output +2021-07-11 06:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query schema +struct +-- !query output +2021-07-10 21:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query schema +struct +-- !query output +2021-07-10 14:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out index bf4578b803196..ee8a72c315041 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out @@ -211,6 +211,218 @@ org.apache.spark.SparkDateTimeException } +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') +-- !query schema +struct +-- !query output +2021-07-10 10:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') +-- !query schema +struct +-- !query output +2021-07-11 06:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') +-- !query schema +struct +-- !query output +2021-07-10 23:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') +-- !query schema +struct +-- !query output +2021-07-10 21:30:45.678 + + +-- !query +SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') +-- !query schema +struct +-- !query output +2021-07-10 14:30:45.678 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 50, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, 'UTC') +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, 'UTC') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 40, + "fragment" : "make_timestamp(NULL, NULL, 'UTC')" + } ] +} + + +-- !query +SELECT make_timestamp(NULL, TIME'00:00:00', NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 49, + "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) +-- !query schema +struct +-- !query output +NULL + + +-- !query +SELECT make_timestamp(NULL, NULL, NULL) +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.AnalysisException +{ + "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", + "sqlState" : "42605", + "messageParameters" : { + "actualNum" : "3", + "docroot" : "https://spark.apache.org/docs/latest", + "expectedNum" : "[2, 3, 6, 7]", + "functionName" : "`make_timestamp`" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 39, + "fragment" : "make_timestamp(NULL, NULL, NULL)" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema From e1591688bf743171dec6302ed3eee6e884dbb53b Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Fri, 18 Jul 2025 15:29:49 +0200 Subject: [PATCH 5/9] Fix failing tests --- .../expressions/datetimeExpressions.scala | 57 ++++++++++--------- .../expressions/DateExpressionsSuite.scala | 4 +- .../sql-functions/sql-expression-schema.md | 4 +- 3 files changed, 34 insertions(+), 31 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 c459542a52060..299802beea8d2 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 @@ -3099,9 +3099,9 @@ case class TryMakeTimestamp( examples = """ Examples: > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); - 2014-12-28 06:30:45.887 + 2014-12-27 22:30:45.887 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); - 2014-12-28 06:30:45.887 + 2014-12-27 21:30:45.887 """, group = "datetime_funcs", since = "4.1.0") @@ -3122,24 +3122,16 @@ case class MakeTimestampFromDateTime( override def inputTypes: Seq[AbstractDataType] = Seq(DateType, AnyTimeType) ++ timezone.map(_ => StringTypeWithCollation(supportsTrimCollation = true)) - override def replacement: Expression = timezone match { - case Some(tz) => - StaticInvoke( - classOf[DateTimeUtils.type], - TimestampType, - "makeTimestamp", - Seq(date, time, tz), - Seq(date.dataType, time.dataType, tz.dataType), - returnNullable = children.exists(_.nullable)) - case None => - val defaultZoneIdExpr = Literal("+00:00") - StaticInvoke( - classOf[DateTimeUtils.type], - TimestampType, - "makeTimestamp", - Seq(date, time, defaultZoneIdExpr), - Seq(date.dataType, time.dataType, defaultZoneIdExpr.dataType), - returnNullable = children.exists(_.nullable)) + override def replacement: Expression = { + // If timezone is not provided, we use UTC, i.e. +00:00. + val zoneIdExpr = timezone.getOrElse(Literal("+00:00")) + StaticInvoke( + classOf[DateTimeUtils.type], + TimestampType, + "makeTimestamp", + Seq(date, time, zoneIdExpr), + Seq(date.dataType, time.dataType, zoneIdExpr.dataType), + returnNullable = children.exists(_.nullable)) } override def prettyName: String = "make_timestamp" @@ -3184,9 +3176,9 @@ case class MakeTimestampFromDateTime( > SELECT _FUNC_(2014, 12, 28, 6, 30, 45.887, 'CET'); 2014-12-27 21:30:45.887 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); - 2014-12-28 06:30:45.887 - > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); 2014-12-27 22:30:45.887 + > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); + 2014-12-27 21:30:45.887 """, group = "datetime_funcs", since = "4.1.0") @@ -3195,19 +3187,30 @@ object MakeTimestampExpressionBuilder extends ExpressionBuilder { override def build(funcName: String, expressions: Seq[Expression]): Expression = { val numArgs = expressions.length if (numArgs == 2) { - MakeTimestampFromDateTime(expressions(0), expressions(1)) - } else if (numArgs == 3 && expressions(0).dataType == DateType) { - // This is date, time, timezone - MakeTimestampFromDateTime(expressions(0), expressions(1), Some(expressions(2))) + // date, time + MakeTimestampFromDateTime( + expressions(0), + expressions(1) + ) + } else if (numArgs == 3) { + // date, time, timezone + MakeTimestampFromDateTime( + expressions(0), + expressions(1), + Some(expressions(2)) + ) } else if (numArgs == 6) { + // year, month, day, hour, min, sec MakeTimestamp( expressions(0), expressions(1), expressions(2), expressions(3), expressions(4), - expressions(5)) + expressions(5) + ) } else if (numArgs == 7) { + // year, month, day, hour, min, sec, timezone MakeTimestamp( expressions(0), expressions(1), 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 8291100723162..2160e94b19978 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 @@ -2176,7 +2176,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { MakeTimestampFromDateTime(dateLit("2023-10-01"), Literal(null, TimeType())), null ) - // Test with both date and time as null. + // Test with null date and null time. checkEvaluation( MakeTimestampFromDateTime(Literal(null, DateType), Literal(null, TimeType())), null @@ -2253,7 +2253,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { ), null ) - // Test with both date and time as null. + // Test with null date and null time. checkEvaluation( MakeTimestampFromDateTime( Literal(null, DateType), diff --git a/sql/core/src/test/resources/sql-functions/sql-expression-schema.md b/sql/core/src/test/resources/sql-functions/sql-expression-schema.md index 3b0b21b9cd776..0499b7fc6519b 100644 --- a/sql/core/src/test/resources/sql-functions/sql-expression-schema.md +++ b/sql/core/src/test/resources/sql-functions/sql-expression-schema.md @@ -208,7 +208,7 @@ | org.apache.spark.sql.catalyst.expressions.MakeDate | make_date | SELECT make_date(2013, 7, 15) | struct | | org.apache.spark.sql.catalyst.expressions.MakeInterval | make_interval | SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001) | struct | | org.apache.spark.sql.catalyst.expressions.MakeTime | make_time | SELECT make_time(6, 30, 45.887) | struct | -| org.apache.spark.sql.catalyst.expressions.MakeTimestamp | make_timestamp | SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887) | struct | +| org.apache.spark.sql.catalyst.expressions.MakeTimestampExpressionBuilder | make_timestamp | SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887) | struct | | org.apache.spark.sql.catalyst.expressions.MakeTimestampLTZExpressionBuilder | make_timestamp_ltz | SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887) | struct | | org.apache.spark.sql.catalyst.expressions.MakeTimestampNTZExpressionBuilder | make_timestamp_ntz | SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887) | struct | | org.apache.spark.sql.catalyst.expressions.MakeValidUTF8 | make_valid_utf8 | SELECT make_valid_utf8('Spark') | struct | @@ -480,4 +480,4 @@ | org.apache.spark.sql.catalyst.expressions.xml.XPathList | xpath | SELECT xpath('b1b2b3c1c2','a/b/text()') | structb1b2b3c1c2, a/b/text()):array> | | org.apache.spark.sql.catalyst.expressions.xml.XPathLong | xpath_long | SELECT xpath_long('12', 'sum(a/b)') | struct12, sum(a/b)):bigint> | | org.apache.spark.sql.catalyst.expressions.xml.XPathShort | xpath_short | SELECT xpath_short('12', 'sum(a/b)') | struct12, sum(a/b)):smallint> | -| org.apache.spark.sql.catalyst.expressions.xml.XPathString | xpath_string | SELECT xpath_string('bcc','a/c') | structbcc, a/c):string> | +| org.apache.spark.sql.catalyst.expressions.xml.XPathString | xpath_string | SELECT xpath_string('bcc','a/c') | structbcc, a/c):string> | \ No newline at end of file From da2462f01eb737cf9e9e1bedcdd8e056f6dc0f32 Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Sat, 19 Jul 2025 13:34:01 +0200 Subject: [PATCH 6/9] Golden files --- .../analyzer-results/datetime-legacy.sql.out | 76 +---------------- .../nonansi/timestamp.sql.out | 76 +---------------- .../analyzer-results/timestamp.sql.out | 76 +---------------- .../timestampNTZ/timestamp-ansi.sql.out | 76 +---------------- .../timestampNTZ/timestamp.sql.out | 76 +---------------- .../sql-tests/results/datetime-legacy.sql.out | 84 ++----------------- .../results/nonansi/timestamp.sql.out | 84 ++----------------- .../sql-tests/results/timestamp.sql.out | 84 ++----------------- .../timestampNTZ/timestamp-ansi.sql.out | 84 ++----------------- .../results/timestampNTZ/timestamp.sql.out | 84 ++----------------- 10 files changed, 60 insertions(+), 740 deletions(-) diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out index 052bfa3edd8df..0e9e236cded8d 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out @@ -1188,24 +1188,7 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -1223,47 +1206,13 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -1275,24 +1224,7 @@ SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out index 8792c6e158c84..be86a9519a766 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out @@ -232,24 +232,7 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -267,47 +250,13 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -319,24 +268,7 @@ SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out index 2a8395a6ee58b..726a646320e79 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out @@ -232,24 +232,7 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -267,47 +250,13 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -319,24 +268,7 @@ SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out index c0b35c30526ad..e2b983ba01504 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out @@ -233,24 +233,7 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -268,47 +251,13 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -320,24 +269,7 @@ SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out index d0c0f1848a197..7e00d0199dae9 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out @@ -233,24 +233,7 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', 'UTC') -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -268,47 +251,13 @@ SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00', NULL) -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query @@ -320,24 +269,7 @@ SELECT make_timestamp(DATE'1970-01-01', NULL, NULL) -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query analysis -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +[Analyzer test output redacted due to nondeterminism] -- !query diff --git a/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out b/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out index 851831052a804..7e2c19395f37d 100644 --- a/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out @@ -1495,26 +1495,9 @@ struct -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +NULL -- !query @@ -1536,51 +1519,17 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +NULL -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +NULL -- !query @@ -1594,26 +1543,9 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +NULL -- !query diff --git a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out index 5e457be4e1937..974844767487f 100644 --- a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out @@ -271,26 +271,9 @@ struct -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +NULL -- !query @@ -312,51 +295,17 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +NULL -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +NULL -- !query @@ -370,26 +319,9 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +NULL -- !query diff --git a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out index 79b7f9c1f530e..211a71d1c2547 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out @@ -302,26 +302,9 @@ struct -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +NULL -- !query @@ -343,51 +326,17 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +NULL -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +NULL -- !query @@ -401,26 +350,9 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +NULL -- !query diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out index ee8a72c315041..aa4c6f4312e11 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out @@ -302,26 +302,9 @@ struct -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +NULL -- !query @@ -343,51 +326,17 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +NULL -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +NULL -- !query @@ -401,26 +350,9 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +NULL -- !query diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out index 961549497523f..c071f9ec17e2c 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out @@ -271,26 +271,9 @@ struct -- !query SELECT make_timestamp(NULL, TIME'00:00:00', 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 50, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', 'UTC')" - } ] -} +NULL -- !query @@ -312,51 +295,17 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, 'UTC') -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 40, - "fragment" : "make_timestamp(NULL, NULL, 'UTC')" - } ] -} +NULL -- !query SELECT make_timestamp(NULL, TIME'00:00:00', NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 49, - "fragment" : "make_timestamp(NULL, TIME'00:00:00', NULL)" - } ] -} +NULL -- !query @@ -370,26 +319,9 @@ NULL -- !query SELECT make_timestamp(NULL, NULL, NULL) -- !query schema -struct<> +struct -- !query output -org.apache.spark.sql.AnalysisException -{ - "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION", - "sqlState" : "42605", - "messageParameters" : { - "actualNum" : "3", - "docroot" : "https://spark.apache.org/docs/latest", - "expectedNum" : "[2, 3, 6, 7]", - "functionName" : "`make_timestamp`" - }, - "queryContext" : [ { - "objectType" : "", - "objectName" : "", - "startIndex" : 8, - "stopIndex" : 39, - "fragment" : "make_timestamp(NULL, NULL, NULL)" - } ] -} +NULL -- !query From 8b6ca1f1888e44c76e62a424cf3500050ac5f338 Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Sun, 20 Jul 2025 23:47:45 +0200 Subject: [PATCH 7/9] Date only --- .../expressions/datetimeExpressions.scala | 49 +++++++++++------ .../expressions/DateExpressionsSuite.scala | 52 ++++++++++++++----- .../analyzer-results/datetime-legacy.sql.out | 31 ++++++++--- .../nonansi/timestamp.sql.out | 31 ++++++++--- .../analyzer-results/timestamp.sql.out | 31 ++++++++--- .../timestampNTZ/timestamp-ansi.sql.out | 31 ++++++++--- .../timestampNTZ/timestamp.sql.out | 31 ++++++++--- .../resources/sql-tests/inputs/timestamp.sql | 5 ++ .../sql-tests/results/datetime-legacy.sql.out | 24 +++++++++ .../results/nonansi/timestamp.sql.out | 24 +++++++++ .../sql-tests/results/timestamp.sql.out | 24 +++++++++ .../timestampNTZ/timestamp-ansi.sql.out | 24 +++++++++ .../results/timestampNTZ/timestamp.sql.out | 24 +++++++++ 13 files changed, 322 insertions(+), 59 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 e782f95d6c211..a4ae54481a347 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 @@ -3095,11 +3095,13 @@ case class TryMakeTimestamp( arguments = """ Arguments: * date - a date expression - * time - a time expression - * timezone - the time zone identifier. For example, CET, UTC and etc. + * time - a time expression (optional) + * timezone - the time zone identifier (optional). For example, CET, UTC and etc. """, examples = """ Examples: + > SELECT _FUNC_(DATE'2014-12-28'); + 2014-12-27 16:00:00 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); 2014-12-27 22:30:45.887 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); @@ -3110,38 +3112,46 @@ case class TryMakeTimestamp( // scalastyle:on line.size.limit case class MakeTimestampFromDateTime( date: Expression, - time: Expression, + time: Option[Expression] = None, timezone: Option[Expression] = None) extends Expression with RuntimeReplaceable with ExpectsInputTypes { + def this(date: Expression) = + this(date, None, None) + def this(date: Expression, time: Expression) = - this(date, time, None) + this(date, Some(time), None) + def this(date: Expression, time: Expression, timezone: Expression) = - this(date, time, Some(timezone)) + this(date, Some(time), Some(timezone)) - override def children: Seq[Expression] = Seq(date, time) ++ timezone + override def children: Seq[Expression] = Seq(date) ++ time ++ timezone override def inputTypes: Seq[AbstractDataType] = Seq(DateType, AnyTimeType) ++ timezone.map(_ => StringTypeWithCollation(supportsTrimCollation = true)) override def replacement: Expression = { + // If time is not provided, we use midnight, i.e. 00:00:00. + val timeExpr = time.getOrElse(Literal(0L, TimeType(0))) // If timezone is not provided, we use UTC, i.e. +00:00. val zoneIdExpr = timezone.getOrElse(Literal("+00:00")) StaticInvoke( classOf[DateTimeUtils.type], TimestampType, "makeTimestamp", - Seq(date, time, zoneIdExpr), - Seq(date.dataType, time.dataType, zoneIdExpr.dataType), - returnNullable = children.exists(_.nullable)) + Seq(date, timeExpr, zoneIdExpr), + Seq(date.dataType, timeExpr.dataType, zoneIdExpr.dataType), + returnNullable = children.exists(_.nullable) + ) } override def prettyName: String = "make_timestamp" override protected def withNewChildrenInternal( newChildren: IndexedSeq[Expression]): Expression = { + val timeOpt = if (time.isDefined) Some(newChildren(1)) else None val timezoneOpt = if (timezone.isDefined) Some(newChildren(2)) else None - copy(date = newChildren(0), time = newChildren(1), timezone = timezoneOpt) + copy(date = newChildren(0), time = timeOpt, timezone = timezoneOpt) } } @@ -3168,8 +3178,8 @@ case class MakeTimestampFromDateTime( 0 to 60. If the sec argument equals to 60, the seconds field is set to 0 and 1 minute is added to the final timestamp. * date - a date expression - * time - a time expression - * timezone - the time zone identifier. For example, CET, UTC and etc. + * time - a time expression (optional) + * timezone - the time zone identifier (optional). For example, CET, UTC and etc. """, examples = """ Examples: @@ -3177,6 +3187,8 @@ case class MakeTimestampFromDateTime( 2014-12-28 06:30:45.887 > SELECT _FUNC_(2014, 12, 28, 6, 30, 45.887, 'CET'); 2014-12-27 21:30:45.887 + > SELECT _FUNC_(DATE'2014-12-28'); + 2014-12-27 16:00:00 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887'); 2014-12-27 22:30:45.887 > SELECT _FUNC_(DATE'2014-12-28', TIME'6:30:45.887', 'CET'); @@ -3188,17 +3200,22 @@ case class MakeTimestampFromDateTime( object MakeTimestampExpressionBuilder extends ExpressionBuilder { override def build(funcName: String, expressions: Seq[Expression]): Expression = { val numArgs = expressions.length - if (numArgs == 2) { + if (numArgs == 1) { + // date + MakeTimestampFromDateTime( + expressions(0) + ) + } else if (numArgs == 2) { // date, time MakeTimestampFromDateTime( expressions(0), - expressions(1) + Some(expressions(1)) ) } else if (numArgs == 3) { // date, time, timezone MakeTimestampFromDateTime( expressions(0), - expressions(1), + Some(expressions(1)), Some(expressions(2)) ) } else if (numArgs == 6) { @@ -3223,7 +3240,7 @@ object MakeTimestampExpressionBuilder extends ExpressionBuilder { Some(expressions(6)) ) } else { - throw QueryCompilationErrors.wrongNumArgsError(funcName, Seq(2, 3, 6, 7), numArgs) + throw QueryCompilationErrors.wrongNumArgsError(funcName, Seq(1, 2, 3, 6, 7), numArgs) } } } 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 2160e94b19978..041faa49605da 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 @@ -2159,26 +2159,52 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { localDateTimeToMicros(LocalDateTime.parse(timestamp), zoneId) } + test("SPARK-51415: make timestamp from date") { + // Test with valid date. + checkEvaluation( + MakeTimestampFromDateTime(dateLit("2023-10-01")), + timestampToMicros("2023-10-01T00:00:00", UTC) + ) + + // Test with null date. + checkEvaluation( + MakeTimestampFromDateTime(Literal(null, DateType)), + null + ) + } + test("SPARK-51415: make timestamp from date and time") { // Test with valid date and time. checkEvaluation( - MakeTimestampFromDateTime(dateLit("2023-10-01"), timeLit("12:34:56.123456")), + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + Some(timeLit("12:34:56.123456")) + ), timestampToMicros("2023-10-01T12:34:56.123456", UTC) ) // Test with null date. checkEvaluation( - MakeTimestampFromDateTime(Literal(null, DateType), timeLit("12:34:56.123456")), + MakeTimestampFromDateTime( + Literal(null, DateType), + Some(timeLit("12:34:56.123456")) + ), null ) // Test with null time. checkEvaluation( - MakeTimestampFromDateTime(dateLit("2023-10-01"), Literal(null, TimeType())), + MakeTimestampFromDateTime( + dateLit("2023-10-01"), + Some(Literal(null, TimeType())) + ), null ) // Test with null date and null time. checkEvaluation( - MakeTimestampFromDateTime(Literal(null, DateType), Literal(null, TimeType())), + MakeTimestampFromDateTime( + Literal(null, DateType), + Some(Literal(null, TimeType()) + )), null ) } @@ -2188,7 +2214,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal("-09:30")) ), timestampToMicros("2023-10-01T12:34:56.123456", MIT) @@ -2196,7 +2222,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal("-08:00")) ), timestampToMicros("2023-10-01T12:34:56.123456", PST) @@ -2204,7 +2230,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal("+00:00")) ), timestampToMicros("2023-10-01T12:34:56.123456", UTC) @@ -2212,7 +2238,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal("+01:00")) ), timestampToMicros("2023-10-01T12:34:56.123456", CET) @@ -2220,7 +2246,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal("+09:00")) ), timestampToMicros("2023-10-01T12:34:56.123456", JST) @@ -2230,7 +2256,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( Literal(null, DateType), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal("+00:00")) ), null @@ -2239,7 +2265,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - Literal(null, TimeType()), + Some(Literal(null, TimeType())), Some(Literal("+00:00")) ), null @@ -2248,7 +2274,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( dateLit("2023-10-01"), - timeLit("12:34:56.123456"), + Some(timeLit("12:34:56.123456")), Some(Literal(null, StringType)) ), null @@ -2257,7 +2283,7 @@ class DateExpressionsSuite extends SparkFunSuite with ExpressionEvalHelper { checkEvaluation( MakeTimestampFromDateTime( Literal(null, DateType), - Literal(null, TimeType()), + Some(Literal(null, TimeType())), Some(Literal("+00:00")) ), null diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out index 0e9e236cded8d..38e6b2461b000 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/datetime-legacy.sql.out @@ -1113,10 +1113,29 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), None, None) AS make_timestamp(make_date(2021, 7, 11))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +- OneRowRelation @@ -1147,35 +1166,35 @@ SELECT make_timestamp(NULL, NULL) -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out index be86a9519a766..ea264827d9b2c 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out @@ -157,10 +157,29 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), None, None) AS make_timestamp(make_date(2021, 7, 11))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +- OneRowRelation @@ -191,35 +210,35 @@ SELECT make_timestamp(NULL, NULL) -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out index 726a646320e79..275134391acbf 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out @@ -157,10 +157,29 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), None, None) AS make_timestamp(make_date(2021, 7, 11))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +- OneRowRelation @@ -191,35 +210,35 @@ SELECT make_timestamp(NULL, NULL) -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out index e2b983ba01504..a95a50d5f6ce0 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp-ansi.sql.out @@ -158,10 +158,29 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, true), None, None) AS make_timestamp(make_date(2021, 7, 11))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +- OneRowRelation @@ -192,35 +211,35 @@ SELECT make_timestamp(NULL, NULL) -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, true), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +Project [make_timestamp(make_date(2021, 7, 11, true), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out index 7e00d0199dae9..ef1eb2ac3936d 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out @@ -158,10 +158,29 @@ Project [make_timestamp(1, 1, 1, 1, 1, cast(999.999999 as decimal(16,6)), None, +- OneRowRelation +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query analysis +Project [make_timestamp(make_date(2021, 7, 11, false), None, None) AS make_timestamp(make_date(2021, 7, 11))#x] ++- OneRowRelation + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + +-- !query +SELECT make_timestamp(NULL) +-- !query analysis +[Analyzer test output redacted due to nondeterminism] + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), None) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678))#x] +- OneRowRelation @@ -192,35 +211,35 @@ SELECT make_timestamp(NULL, NULL) -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'MIT') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(MIT)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), MIT)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'PST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(PST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), PST)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'UTC') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(UTC)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), UTC)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'CET') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(CET)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), CET)#x] +- OneRowRelation -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678), 'JST') -- !query analysis -Project [make_timestamp(make_date(2021, 7, 11, false), make_time(6, 30, cast(45.678 as decimal(16,6))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +Project [make_timestamp(make_date(2021, 7, 11, false), Some(make_time(6, 30, cast(45.678 as decimal(16,6)))), Some(JST)) AS make_timestamp(make_date(2021, 7, 11), make_time(6, 30, 45.678), JST)#x] +- OneRowRelation diff --git a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql index 73f4c12d3245f..0a4e2b531e5d1 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql @@ -26,6 +26,11 @@ SELECT make_timestamp(1, 1, 1, 1, 1, 59.999999); SELECT make_timestamp(1, 1, 1, 1, 1, 99.999999); SELECT make_timestamp(1, 1, 1, 1, 1, 999.999999); +-- SPARK-51415: timestamp date constructor. +SELECT make_timestamp(make_date(2021, 07, 11)); +SELECT make_timestamp(DATE'1970-01-01'); +SELECT make_timestamp(NULL); + -- SPARK-51415: timestamp date + time constructor. SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)); SELECT make_timestamp(DATE'1970-01-01', TIME'00:00:00'); diff --git a/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out b/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out index 7e2c19395f37d..16c3c1f48aa19 100644 --- a/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/datetime-legacy.sql.out @@ -1404,6 +1404,30 @@ org.apache.spark.SparkDateTimeException } +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query schema +struct +-- !query output +2021-07-10 17:00:00 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL) +-- !query schema +struct +-- !query output +NULL + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out index 974844767487f..5e3be68fd9a78 100644 --- a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out @@ -180,6 +180,30 @@ struct NULL +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query schema +struct +-- !query output +2021-07-10 17:00:00 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL) +-- !query schema +struct +-- !query output +NULL + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out index 211a71d1c2547..d5f577cff3bb8 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out @@ -211,6 +211,30 @@ org.apache.spark.SparkDateTimeException } +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query schema +struct +-- !query output +2021-07-10 17:00:00 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL) +-- !query schema +struct +-- !query output +NULL + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out index aa4c6f4312e11..b24fcfcc0e1dc 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp-ansi.sql.out @@ -211,6 +211,30 @@ org.apache.spark.SparkDateTimeException } +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query schema +struct +-- !query output +2021-07-10 17:00:00 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL) +-- !query schema +struct +-- !query output +NULL + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out index c071f9ec17e2c..556ab6450d965 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out @@ -180,6 +180,30 @@ struct NULL +-- !query +SELECT make_timestamp(make_date(2021, 07, 11)) +-- !query schema +struct +-- !query output +2021-07-10 17:00:00 + + +-- !query +SELECT make_timestamp(DATE'1970-01-01') +-- !query schema +struct +-- !query output +1969-12-31 16:00:00 + + +-- !query +SELECT make_timestamp(NULL) +-- !query schema +struct +-- !query output +NULL + + -- !query SELECT make_timestamp(make_date(2021, 07, 11), make_time(6, 30, 45.678)) -- !query schema From b7afa683e42a6628cec4b54cd54d546bc7fd1628 Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Tue, 22 Jul 2025 13:55:47 +0200 Subject: [PATCH 8/9] Address comments --- .../expressions/datetimeExpressions.scala | 4 +-- .../sql/catalyst/util/DateTimeUtils.scala | 12 ++++----- .../nonansi/timestamp.sql.out | 24 +++++++++++++++++ .../analyzer-results/timestamp.sql.out | 24 +++++++++++++++++ .../timestampNTZ/timestamp.sql.out | 24 +++++++++++++++++ .../resources/sql-tests/inputs/timestamp.sql | 3 +++ .../results/nonansi/timestamp.sql.out | 26 +++++++++++++++++++ .../sql-tests/results/timestamp.sql.out | 26 +++++++++++++++++++ .../results/timestampNTZ/timestamp.sql.out | 26 +++++++++++++++++++ 9 files changed, 161 insertions(+), 8 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 a4ae54481a347..fe66edfcee629 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 @@ -3090,7 +3090,7 @@ case class TryMakeTimestamp( // scalastyle:off line.size.limit @ExpressionDescription( usage = """ - _FUNC_(date [, time [, timezone]]) - Create timestamp from date and time fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. + _FUNC_(date[, time[, timezone]]) - Create timestamp from date and time fields. """, arguments = """ Arguments: @@ -3165,7 +3165,7 @@ case class MakeTimestampFromDateTime( usage = """ _FUNC_(year, month, day, hour, min, sec[, timezone]) - Create the current timestamp with local time zone from year, month, day, hour, min, sec and timezone fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. - _FUNC_(date [, time [, timezone]]) - Create timestamp from date and time fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead. + _FUNC_(date[, time[, timezone]]) - Create timestamp from date and time fields. """, arguments = """ Arguments: 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 e60dc3976ed9c..4c28217de68fb 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 @@ -839,10 +839,10 @@ object DateTimeUtils extends SparkDateTimeUtils { /** * Makes a timestamp without time zone from a date and a local time. * - * @param days The number of days since the epoch. 1970-01-01. + * @param days The number of days since the epoch 1970-01-01. * Negative numbers represent earlier days. * @param nanos The number of nanoseconds within the day since the midnight. - * @return The number of microseconds since the epoch of 1970-01-01 00:00:00Z. + * @return The number of microseconds since the epoch 1970-01-01 00:00:00Z. */ def makeTimestampNTZ(days: Int, nanos: Long): Long = { localDateTimeToMicros(LocalDateTime.of(daysToLocalDate(days), nanosToLocalTime(nanos))) @@ -851,11 +851,11 @@ object DateTimeUtils extends SparkDateTimeUtils { /** * Makes a timestamp from a date and a local time. * - * @param days The number of days since the epoch. 1970-01-01. + * @param days The number of days since the epoch 1970-01-01. * Negative numbers represent earlier days. * @param nanos The number of nanoseconds within the day since the midnight. * @param zoneId The time zone ID at which the operation is performed. - * @return The number of microseconds since the epoch of 1970-01-01 00:00:00Z. + * @return The number of microseconds since the epoch 1970-01-01 00:00:00Z. */ def makeTimestamp(days: Int, nanos: Long, zoneId: ZoneId): Long = { val ldt = LocalDateTime.of(daysToLocalDate(days), nanosToLocalTime(nanos)) @@ -865,11 +865,11 @@ object DateTimeUtils extends SparkDateTimeUtils { /** * Makes a timestamp from a date and a local time with timezone string. * - * @param days The number of days since the epoch. 1970-01-01. + * @param days The number of days since the epoch 1970-01-01. * Negative numbers represent earlier days. * @param nanos The number of nanoseconds within the day since the midnight. * @param timezone The time zone string. - * @return The number of microseconds since the epoch of 1970-01-01 00:00:00Z. + * @return The number of microseconds since the epoch 1970-01-01 00:00:00Z. */ def makeTimestamp(days: Int, nanos: Long, timezone: UTF8String): Long = { val zoneId = getZoneId(timezone.toString) diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out index ea264827d9b2c..39d68ec22e056 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out @@ -290,6 +290,30 @@ SELECT make_timestamp(NULL, NULL, NULL) [Analyzer test output redacted due to nondeterminism] +-- !query +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 74, + "fragment" : "make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out index 275134391acbf..8ea08294b2440 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out @@ -290,6 +290,30 @@ SELECT make_timestamp(NULL, NULL, NULL) [Analyzer test output redacted due to nondeterminism] +-- !query +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 74, + "fragment" : "make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out index ef1eb2ac3936d..210bfec9dd0a8 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out @@ -291,6 +291,30 @@ SELECT make_timestamp(NULL, NULL, NULL) [Analyzer test output redacted due to nondeterminism] +-- !query +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 74, + "fragment" : "make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql index 0a4e2b531e5d1..04787458b1e9e 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql @@ -53,6 +53,9 @@ SELECT make_timestamp(NULL, TIME'00:00:00', NULL); SELECT make_timestamp(DATE'1970-01-01', NULL, NULL); SELECT make_timestamp(NULL, NULL, NULL); +-- SPARK-51415: unsupported parameters. +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET'); + -- [SPARK-31710] TIMESTAMP_SECONDS, TIMESTAMP_MILLISECONDS and TIMESTAMP_MICROSECONDS that always create timestamp_ltz select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null); select TIMESTAMP_SECONDS(1.23), TIMESTAMP_SECONDS(1.23d), TIMESTAMP_SECONDS(FLOAT(1.23)); diff --git a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out index 5e3be68fd9a78..3637a380a9ea7 100644 --- a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out @@ -348,6 +348,32 @@ struct NULL +-- !query +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 74, + "fragment" : "make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out index d5f577cff3bb8..9c5faef43843c 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out @@ -379,6 +379,32 @@ struct NULL +-- !query +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 74, + "fragment" : "make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out index 556ab6450d965..563beddd8d024 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out @@ -348,6 +348,32 @@ struct NULL +-- !query +SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 74, + "fragment" : "make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema From 536b0bc61f9e71f7389b882eb1e7e631f854a67d Mon Sep 17 00:00:00 2001 From: Uros Bojanic Date: Tue, 22 Jul 2025 14:11:31 +0200 Subject: [PATCH 9/9] Add more tests --- .../nonansi/timestamp.sql.out | 72 +++++++++++++++++ .../analyzer-results/timestamp.sql.out | 72 +++++++++++++++++ .../timestampNTZ/timestamp.sql.out | 72 +++++++++++++++++ .../resources/sql-tests/inputs/timestamp.sql | 5 +- .../results/nonansi/timestamp.sql.out | 78 +++++++++++++++++++ .../sql-tests/results/timestamp.sql.out | 78 +++++++++++++++++++ .../results/timestampNTZ/timestamp.sql.out | 78 +++++++++++++++++++ 7 files changed, 454 insertions(+), 1 deletion(-) diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out index 39d68ec22e056..7ccf42e2286e8 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/nonansi/timestamp.sql.out @@ -314,6 +314,78 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException } +-- !query +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 78, + "fragment" : "make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 79, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 83, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out index 8ea08294b2440..e6b5735541d33 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestamp.sql.out @@ -314,6 +314,78 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException } +-- !query +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 78, + "fragment" : "make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 79, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 83, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out index 210bfec9dd0a8..84f70e35bb01b 100644 --- a/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/analyzer-results/timestampNTZ/timestamp.sql.out @@ -315,6 +315,78 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException } +-- !query +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 78, + "fragment" : "make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 79, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET') +-- !query analysis +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 83, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query analysis diff --git a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql index 04787458b1e9e..96b5ab9fa35ce 100644 --- a/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql +++ b/sql/core/src/test/resources/sql-tests/inputs/timestamp.sql @@ -53,8 +53,11 @@ SELECT make_timestamp(NULL, TIME'00:00:00', NULL); SELECT make_timestamp(DATE'1970-01-01', NULL, NULL); SELECT make_timestamp(NULL, NULL, NULL); --- SPARK-51415: unsupported parameters. +-- SPARK-51415: unsupported input types. SELECT make_timestamp(timestamp '2018-11-17 13:33:33', TIME'0:0:0', 'CET'); +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET'); +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET'); +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET'); -- [SPARK-31710] TIMESTAMP_SECONDS, TIMESTAMP_MILLISECONDS and TIMESTAMP_MICROSECONDS that always create timestamp_ltz select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null); diff --git a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out index 3637a380a9ea7..fca753f80846c 100644 --- a/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/nonansi/timestamp.sql.out @@ -374,6 +374,84 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException } +-- !query +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 78, + "fragment" : "make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 79, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 83, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out index 9c5faef43843c..4a680d5258660 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestamp.sql.out @@ -405,6 +405,84 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException } +-- !query +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 78, + "fragment" : "make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 79, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 83, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema diff --git a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out index 563beddd8d024..39867a09470a7 100644 --- a/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out +++ b/sql/core/src/test/resources/sql-tests/results/timestampNTZ/timestamp.sql.out @@ -374,6 +374,84 @@ org.apache.spark.sql.catalyst.ExtendedAnalysisException } +-- !query +SELECT make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "first", + "requiredType" : "\"DATE\"", + "sqlExpr" : "\"make_timestamp(TIMESTAMP_NTZ '2018-11-17 13:33:33', TIME '00:00:00', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 78, + "fragment" : "make_timestamp(timestamp_ntz '2018-11-17 13:33:33', TIME'0:0:0', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 79, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp '2018-11-17 13:33:33', 'CET')" + } ] +} + + +-- !query +SELECT make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET') +-- !query schema +struct<> +-- !query output +org.apache.spark.sql.catalyst.ExtendedAnalysisException +{ + "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE", + "sqlState" : "42K09", + "messageParameters" : { + "inputSql" : "\"TIMESTAMP_NTZ '2018-11-17 13:33:33'\"", + "inputType" : "\"TIMESTAMP_NTZ\"", + "paramIndex" : "second", + "requiredType" : "\"TIME\"", + "sqlExpr" : "\"make_timestamp(DATE '1970-01-01', TIMESTAMP_NTZ '2018-11-17 13:33:33', CET)\"" + }, + "queryContext" : [ { + "objectType" : "", + "objectName" : "", + "startIndex" : 8, + "stopIndex" : 83, + "fragment" : "make_timestamp(DATE'1970-01-01', timestamp_ntz '2018-11-17 13:33:33', 'CET')" + } ] +} + + -- !query select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null) -- !query schema