Bug#30786762: FAILED ASSERTION FOR DATES WITH ZERO OR ABOVE

TIMESTAMP LIMIT

This bug report unfortunately contained two independent
bugs. The first one concerns bounds checking for timestamp
literals and was fixed along with bug no 31239157.

This patch fixes the second bug, failed assertion for
timestamp literals with zero month and a time zone
displacement. We calculate the number of seconds since the
unix epoch in order to adjust time zone diplacement, and the
function doing this, sec_since_epoch64(), asserts that the
month be non-zero.

We fix this by adding a check for zero month, and for
consistency we disallow a day zero as well, for timestamp
literals with a time zone displacement, raising an
error. This check runs independent of sql_mode.

Change-Id: Idfea577c6528afa2d9bd5f30b2c3d8db9525bd8d

Author: Martin Hansson

mysql-test/r/time_zone.result

@@ -588,3 +588,25 @@ a
 1970-01-01 00:00:01.000000
 SET time_zone = DEFAULT;
 DROP TABLE t1, t2;
+#
+# Bug#30786762: FAILED ASSERTION FOR DATES WITH ZERO OR ABOVE TIMESTAMP
+# LIMIT
+#
+SET sql_mode = regexp_replace(@@sql_mode, 'NO_ZERO_IN_DATE', '');
+Warnings:
+Warning	3135	'NO_ZERO_DATE', 'NO_ZERO_IN_DATE' and 'ERROR_FOR_DIVISION_BY_ZERO' sql modes should be used with strict mode. They will be merged with strict mode in a future release.
+SELECT TIMESTAMP '2020-00-01 08:00:00.123456+00:00';
+ERROR 22007: Truncated incorrect temporal value: '2020-00-01 08:00:00+0:00'
+SELECT TIMESTAMP '2020-01-00 08:00:00.123456+00:00';
+ERROR 22007: Truncated incorrect temporal value: '2020-01-00 08:00:00+0:00'
+CREATE TABLE t1 ( a DATETIME(6) );
+INSERT INTO t1 VALUES ( '2020-00-01 00:00:00.123456+00:00' );
+ERROR 22007: Truncated incorrect temporal value: '2020-00-01 00:00:00+0:00'
+INSERT INTO t1 VALUES ( '2020-01-00 00:00:00.123456+00:00' );
+ERROR 22007: Truncated incorrect temporal value: '2020-01-00 00:00:00+0:00'
+SELECT * FROM t1 WHERE a = '2020-00-01 00:00:00.123456+00:00';
+ERROR 22007: Truncated incorrect temporal value: '2020-00-01 00:00:00+0:00'
+SELECT * FROM t1 WHERE a = '2020-01-00 00:00:00.123456+00:00';
+ERROR 22007: Truncated incorrect temporal value: '2020-01-00 00:00:00+0:00'
+DROP TABLE t1;
+SET sql_mode = DEFAULT;

mysql-test/t/time_zone.test

@@ -455,3 +455,31 @@ SELECT * FROM t2;
 SET time_zone = DEFAULT;
 
 DROP TABLE t1, t2;
+
+--echo #
+--echo # Bug#30786762: FAILED ASSERTION FOR DATES WITH ZERO OR ABOVE TIMESTAMP
+--echo # LIMIT
+--echo #
+
+SET sql_mode = regexp_replace(@@sql_mode, 'NO_ZERO_IN_DATE', '');
+
+--error ER_TRUNCATED_WRONG_VALUE
+SELECT TIMESTAMP '2020-00-01 08:00:00.123456+00:00';
+--error ER_TRUNCATED_WRONG_VALUE
+SELECT TIMESTAMP '2020-01-00 08:00:00.123456+00:00';
+
+CREATE TABLE t1 ( a DATETIME(6) );
+
+--error ER_TRUNCATED_WRONG_VALUE
+INSERT INTO t1 VALUES ( '2020-00-01 00:00:00.123456+00:00' );
+--error ER_TRUNCATED_WRONG_VALUE
+INSERT INTO t1 VALUES ( '2020-01-00 00:00:00.123456+00:00' );
+
+--error ER_TRUNCATED_WRONG_VALUE
+SELECT * FROM t1 WHERE a = '2020-00-01 00:00:00.123456+00:00';
+--error ER_TRUNCATED_WRONG_VALUE
+SELECT * FROM t1 WHERE a = '2020-01-00 00:00:00.123456+00:00';
+
+DROP TABLE t1;
+
+SET sql_mode = DEFAULT;

sql/field.cc

@@ -4609,7 +4609,7 @@ type_conversion_status Field_temporal::store(const char *str, size_t len,
       error = TYPE_ERR_BAD_VALUE;
   } else {
     if (ltime.time_type == MYSQL_TIMESTAMP_DATETIME_TZ) {
-      if (adjust_time_zone_displacement(current_thd->time_zone(), &ltime))
+      if (convert_time_zone_displacement(current_thd->time_zone(), &ltime))
         return TYPE_ERR_BAD_VALUE;
     }
     error = time_warning_to_type_conversion_status(status.warnings);
@@ -5951,7 +5951,7 @@ type_conversion_status Field_datetimef::store_internal(const MYSQL_TIME *ltime,
     - convert to the local time zone
   */
   MYSQL_TIME temp_t = *ltime;
-  if (adjust_time_zone_displacement(current_thd->time_zone(), &temp_t))
+  if (convert_time_zone_displacement(current_thd->time_zone(), &temp_t))
     return TYPE_ERR_BAD_VALUE;
   store_packed(TIME_to_longlong_datetime_packed(temp_t));
 

sql/item_create.cc

@@ -80,7 +80,7 @@
 #include "sql/sql_udf.h"
 #include "sql/system_variables.h"
 #include "sql_string.h"
-#include "tztime.h"  // adjust_time_zone
+#include "tztime.h"  // convert_time_zone_displacement
 
 /**
   @addtogroup GROUP_PARSER
@@ -2075,7 +2075,7 @@ Item *create_temporal_literal(THD *thd, const char *str, size_t length,
           (ltime.time_type == MYSQL_TIMESTAMP_DATETIME ||
            ltime.time_type == MYSQL_TIMESTAMP_DATETIME_TZ) &&
           !status.warnings) {
-        if (adjust_time_zone_displacement(thd->time_zone(), &ltime))
+        if (convert_time_zone_displacement(thd->time_zone(), &ltime))
           return nullptr;
         item = new (thd->mem_root) Item_datetime_literal(
             &ltime, status.fractional_digits, thd->time_zone());

sql/item_timefunc.cc

@@ -1780,7 +1780,7 @@ void MYSQL_TIME_cache::set_datetime(MYSQL_TIME *ltime, uint8 dec_arg,
   DBUG_ASSERT(ltime->time_type == MYSQL_TIMESTAMP_DATETIME ||
               ltime->time_type == MYSQL_TIMESTAMP_DATETIME_TZ);
   time = *ltime;
-  if (adjust_time_zone_displacement(tz, &time)) {
+  if (convert_time_zone_displacement(tz, &time)) {
     DBUG_ASSERT(false);
   }
   time_packed = TIME_to_longlong_datetime_packed(time);

sql/sql_const_folding.cc

@@ -898,7 +898,7 @@ static bool analyze_timestamp_field_constant(THD *thd, const Item_field *f,
               Item_func::DATETIME_LITERAL) {
         /* User supplied an ok literal */
       } else {
-        Item *i;
+        Item *i = nullptr;
         /*
           Make a DATETIME literal, unless the field is a DATE and the constant
           has zero time, in which case we make a DATE literal
@@ -917,7 +917,7 @@ static bool analyze_timestamp_field_constant(THD *thd, const Item_field *f,
             *place = RP_INSIDE_TRUNCATED;
           }
           i = new (thd->mem_root) Item_date_literal(&ltime);
-        } else {
+        } else if (!check_time_zone_convertibility(ltime)) {
           i = new (thd->mem_root) Item_datetime_literal(
               &ltime, actual_decimals(&ltime), thd->time_zone());
         }

sql/sql_time.cc

@@ -185,7 +185,7 @@ bool str_to_datetime_with_warn(String *str, MYSQL_TIME *l_time,
   }
 
   if (ret_val) return true;
-  return adjust_time_zone_displacement(thd->time_zone(), l_time);
+  return convert_time_zone_displacement(thd->time_zone(), l_time);
 }
 
 /**
@@ -532,7 +532,7 @@ bool str_to_time_with_warn(String *str, MYSQL_TIME *l_time) {
   }
 
   if (!ret_val)
-    if (adjust_time_zone_displacement(thd->time_zone(), l_time)) return true;
+    if (convert_time_zone_displacement(thd->time_zone(), l_time)) return true;
 
   return ret_val;
 }

sql/tztime.cc

@@ -1020,24 +1020,59 @@ static const String tz_SYSTEM_name("SYSTEM", 6, &my_charset_latin1);
 
 Time_zone *my_tz_find(const int64 displacement);
 
+static void raise_time_zone_conversion_error(const MYSQL_TIME &mt) {
+  char str[MAX_DATE_STRING_REP_LENGTH];
+  // TODO(mhansson) Get the correct number of decimal places into the error
+  // message.  This is non-trivial, as this is part of the meta-data, which
+  // (for some reason) is not included in a MYSQL_TIME.
+  my_datetime_to_str(mt, str, 0);
+
+  my_error(ER_TRUNCATED_WRONG_VALUE, myf(0), "temporal", str);
+}
+
+/**
+  Checks that this temporal value can be converted from its specified time
+  zone (if any) to the current time zone. Specifically, temporal values with
+  zero months or days cannot be converted between time zones.
+
+  @param mt The time to check.
+  @retval false The temporal value has no time zone or can be converted.
+  @retval true Otherwise, and an error was raised.
+*/
+bool check_time_zone_convertibility(const MYSQL_TIME &mt) {
+  if (mt.time_type == MYSQL_TIMESTAMP_DATETIME_TZ &&
+      (mt.month < 1 || mt.day < 1)) {
+    raise_time_zone_conversion_error(mt);
+    return true;
+  }
+  return false;
+}
+
 /**
   Converts a date/time value with time zone to the corresponding date/time value
-  without time zone, adjusted to be in time zone specified by argument @p tz.
+  without time zone, converted to be in time zone specified by argument @p tz.
+
+  Since MySQL doesn't have a data type for temporal values with time zone
+  information, all such values are converted to a value without time zone
+  using this function.
 
-  This function is intended only for the types with time zone, and is a no-op
+  This function is intended only for values with a time zone, and is a no-op
   for all other types.
 
-  If the adjusted value falls outside the range of the `DATETIME` type, an error
-  is raised and `true` returned.
+  The converted value may not fall outside the range of the `DATETIME` type.
+  Also some invalid values cannot be converted because the conversion result
+  would be undefined. In these cases an error is raised.
 
-  @param tz The time zone to adjust according to.
-  @param[in,out] mt Date/Time value to be adjusted.
+  @param tz The time zone to convert according to.
+  @param[in,out] mt Date/Time value to be converted.
 
   @return false on success. true if an error was raised.
 */
-bool adjust_time_zone_displacement(const Time_zone *tz, MYSQL_TIME *mt) {
+bool convert_time_zone_displacement(const Time_zone *tz, MYSQL_TIME *mt) {
   if (mt->time_type != MYSQL_TIMESTAMP_DATETIME_TZ) return false;
 
+  if (check_time_zone_convertibility(*mt)) return true;
+
   MYSQL_TIME out;
   std::int64_t epoch_secs_in_utc =
       sec_since_epoch64(*mt) - mt->time_zone_displacement;
@@ -1048,10 +1083,7 @@ bool adjust_time_zone_displacement(const Time_zone *tz, MYSQL_TIME *mt) {
   out.second_part = microseconds;
 
   if (check_datetime_range(out)) {
-    char str[MAX_DATE_STRING_REP_LENGTH];
-    // to do: Get the correct number of decimal places into the error message.
-    my_datetime_to_str(out, str, 0);
-    my_error(ER_TRUNCATED_WRONG_VALUE, myf(0), "temporal", str);
+    raise_time_zone_conversion_error(out);
     return true;
   }
 

sql/tztime.h

@@ -97,7 +97,8 @@ extern bool my_tz_init(THD *org_thd, const char *default_tzname,
 extern void my_tz_free();
 extern my_time_t sec_since_epoch_TIME(MYSQL_TIME *t);
 
-bool adjust_time_zone_displacement(const Time_zone *tz, MYSQL_TIME *mt);
+bool check_time_zone_convertibility(const MYSQL_TIME &mt);
+bool convert_time_zone_displacement(const Time_zone *tz, MYSQL_TIME *mt);
 my_time_t use_input_time_zone(const MYSQL_TIME *input, bool *in_dst_time_gap);
 void sec_to_TIME(MYSQL_TIME *tmp, my_time_t t, int64 offset);