Merge pull request #3049 from dolthub/elianddb/fix-7300-date-time-overflow-underflow

Fix 7300 date time overflow underflow

Author: elianddb

enginetest/queries/queries.go

@@ -4830,6 +4830,47 @@ SELECT * FROM cte WHERE  d = 2;`,
 		Query:    "SELECT subdate(da, f32/10) from typestable;",
 		Expected: []sql.Row{{time.Date(2019, time.December, 30, 0, 0, 0, 0, time.UTC)}},
 	},
+	{
+		Query:    "SELECT date_add('4444-01-01', INTERVAL 5400000 DAY);",
+		Expected: []sql.Row{{nil}},
+	},
+	{
+		Query:    "SELECT date_add('4444-01-01', INTERVAL -5300000 DAY);",
+		Expected: []sql.Row{{nil}},
+	},
+	{
+		Query:    "SELECT subdate('2008-01-02', 12e10);",
+		Expected: []sql.Row{{nil}},
+	},
+	{
+		Query:    "SELECT date_add('2008-01-02', INTERVAL 1000000 day);",
+		Expected: []sql.Row{{"4745-11-29"}},
+	},
+	{
+		Query:    "SELECT subdate('2008-01-02', INTERVAL 700000 day);",
+		Expected: []sql.Row{{"0091-06-20"}},
+	},
+	{
+		Query: "SELECT date_add('0000-01-01:01:00:00', INTERVAL 0 day);",
+		// MYSQL uses a proleptic gregorian, however, Go's time package does normal gregorian.
+		Expected: []sql.Row{{"0000-01-01 01:00:00"}},
+	},
+	{
+		Query:    "SELECT date_add('9999-12-31:23:59:59.9999994', INTERVAL 0 day);",
+		Expected: []sql.Row{{"9999-12-31 23:59:59.999999"}},
+	},
+	{
+		Query:    "SELECT date_add('9999-12-31:23:59:59.9999995', INTERVAL 0 day);",
+		Expected: []sql.Row{{nil}},
+	},
+	{
+		Query:    "SELECT date_add('9999-12-31:23:59:59.99999945', INTERVAL 0 day);",
+		Expected: []sql.Row{{"9999-12-31 23:59:59.999999"}},
+	},
+	{
+		Query:    "SELECT date_add('9999-12-31:23:59:59.99999944444444444-', INTERVAL 0 day);",
+		Expected: []sql.Row{{nil}},
+	},
 	{
 		Query: `SELECT * FROM (SELECT * FROM (SELECT * FROM (SELECT * FROM othertable) othertable_one) othertable_two) othertable_three WHERE s2 = 'first'`,
 		Expected: []sql.Row{

sql/expression/function/time_math.go

@@ -232,7 +232,7 @@ func (d *DateAdd) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	}
 
 	var dateVal interface{}
-	dateVal, _, err = types.DatetimeMaxPrecision.Convert(ctx, date)
+	dateVal, _, err = types.DatetimeMaxRange.Convert(ctx, date)
 	if err != nil {
 		ctx.Warn(1292, err.Error())
 		return nil, nil
@@ -380,7 +380,7 @@ func (d *DateSub) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	}
 
 	var dateVal interface{}
-	dateVal, _, err = types.DatetimeMaxPrecision.Convert(ctx, date)
+	dateVal, _, err = types.DatetimeMaxRange.Convert(ctx, date)
 	if err != nil {
 		ctx.Warn(1292, err.Error())
 		return nil, nil

sql/expression/interval.go

@@ -237,72 +237,69 @@ const (
 	week = 7 * day
 )
 
-func (td TimeDelta) apply(t time.Time, sign int64) time.Time {
-	y := int64(t.Year())
-	mo := int64(t.Month())
-	d := t.Day()
-	h := t.Hour()
-	min := t.Minute()
-	s := t.Second()
-	ns := t.Nanosecond()
+// isLeapYear determines if a given year is a leap year
+func isLeapYear(year int) bool {
+	return daysInMonth(year, time.February) == 29
+}
 
-	if td.Years != 0 {
-		y += td.Years * sign
-	}
+// daysInMonth returns the number of days in a given month/year combination
+func daysInMonth(year int, month time.Month) int {
+	return time.Date(year, month+1, 0, 0, 0, 0, 0, time.UTC).Day()
+}
 
-	if td.Months != 0 {
-		m := mo + td.Months*sign
-		if m < 1 {
-			mo = 12 + (m % 12)
-			y += m/12 - 1
-		} else if m > 12 {
-			mo = m % 12
-			y += m / 12
+// apply applies the time delta to the given time, using the specified sign
+func (td TimeDelta) apply(t time.Time, sign int64) time.Time {
+	if td.Years != 0 {
+		targetYear := t.Year() + int(td.Years*sign)
+
+		// special handling for Feb 29 on leap years
+		if t.Month() == time.February && t.Day() == 29 && !isLeapYear(targetYear) {
+			// if we're on Feb 29 and target year is not a leap year,
+			// move to Feb 28
+			t = time.Date(targetYear, time.February, 28,
+				t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 		} else {
-			mo = m
-		}
-
-		// Due to the operations done before, month may be zero, which means it's
-		// december.
-		if mo == 0 {
-			mo = 12
+			t = time.Date(targetYear, t.Month(), t.Day(),
+				t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 		}
 	}
 
-	if days := daysInMonth(time.Month(mo), int(y)); days < d {
-		d = days
-	}
-
-	date := time.Date(int(y), time.Month(mo), d, h, min, s, ns, t.Location())
+	if td.Months != 0 {
+		totalMonths := int(t.Month()) - 1 + int(td.Months*sign) // convert to 0-based
 
-	if td.Days != 0 {
-		date = date.Add(time.Duration(td.Days) * day * time.Duration(sign))
-	}
+		// calculate target year and month
+		yearOffset := totalMonths / 12
+		if totalMonths < 0 {
+			yearOffset = (totalMonths - 11) / 12 // handle negative division correctly
+		}
+		targetYear := t.Year() + yearOffset
+		targetMonth := time.Month((totalMonths%12+12)%12 + 1) // ensure positive month
 
-	if td.Hours != 0 {
-		date = date.Add(time.Duration(td.Hours) * time.Hour * time.Duration(sign))
-	}
+		// handle end-of-month edge cases
+		originalDay := t.Day()
+		maxDaysInTargetMonth := daysInMonth(targetYear, targetMonth)
 
-	if td.Minutes != 0 {
-		date = date.Add(time.Duration(td.Minutes) * time.Minute * time.Duration(sign))
-	}
+		targetDay := originalDay
+		if originalDay > maxDaysInTargetMonth {
+			targetDay = maxDaysInTargetMonth
+		}
 
-	if td.Seconds != 0 {
-		date = date.Add(time.Duration(td.Seconds) * time.Second * time.Duration(sign))
+		t = time.Date(targetYear, targetMonth, targetDay,
+			t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
 	}
 
-	if td.Microseconds != 0 {
-		date = date.Add(time.Duration(td.Microseconds) * time.Microsecond * time.Duration(sign))
+	if td.Days != 0 {
+		t = t.AddDate(0, 0, int(td.Days*sign))
 	}
 
-	return date
-}
+	duration := time.Duration(td.Hours*sign)*time.Hour +
+		time.Duration(td.Minutes*sign)*time.Minute +
+		time.Duration(td.Seconds*sign)*time.Second +
+		time.Duration(td.Microseconds*sign)*time.Microsecond
 
-func daysInMonth(month time.Month, year int) int {
-	if month == time.December {
-		return 31
+	if duration != 0 {
+		t = t.Add(duration)
 	}
 
-	date := time.Date(year, month+time.Month(1), 1, 0, 0, 0, 0, time.Local)
-	return date.Add(-1 * day).Day()
+	return t
 }

sql/expression/interval_test.go

@@ -51,10 +51,10 @@ func TestTimeDelta(t *testing.T) {
 			date(2005, time.March, 29, 0, 0, 0, 0),
 		},
 		{
-			"plus overflowing until december",
+			"plus overflowing until december", // #7300 mysql produced 2005-12-29
 			TimeDelta{Months: 22},
 			leapYear,
-			date(2006, time.December, 29, 0, 0, 0, 0),
+			date(2005, time.December, 29, 0, 0, 0, 0),
 		},
 		{
 			"minus overflowing months",

sql/rowexec/insert.go

@@ -261,6 +261,7 @@ func getFieldIndexFromUpdateExpr(updateExpr sql.Expression) (int, bool) {
 
 // resolveValues resolves all VALUES functions.
 func (i *insertIter) resolveValues(ctx *sql.Context, insertRow sql.Row) error {
+	// if vals empty then no need to resolve
 	for _, updateExpr := range i.updateExprs {
 		var err error
 		sql.Inspect(updateExpr, func(expr sql.Expression) bool {

sql/types/datetime.go

@@ -39,18 +39,30 @@ var (
 
 	ErrConvertingToTimeOutOfRange = errors.NewKind("value %q is outside of %v range")
 
-	// datetimeTypeMaxDatetime is the maximum representable Datetime/Date value.
-	datetimeTypeMaxDatetime = time.Date(9999, 12, 31, 23, 59, 59, 999999000, time.UTC)
+	// datetimeTypeMaxDatetime is the maximum representable Datetime/Date value. MYSQL: 9999-12-31 23:59:59.499999 (microseconds)
+	datetimeTypeMaxDatetime = time.Date(9999, 12, 31, 23, 59, 59, 499999000, time.UTC)
 
-	// datetimeTypeMinDatetime is the minimum representable Datetime/Date value.
-	datetimeTypeMinDatetime = time.Date(0, 1, 1, 0, 0, 0, 0, time.UTC)
+	// datetimeTypeMinDatetime is the minimum representable Datetime/Date value. MYSQL: 1000-01-01 00:00:00.000000 (microseconds)
+	datetimeTypeMinDatetime = time.Date(1000, 1, 1, 0, 0, 0, 0, time.UTC)
 
-	// datetimeTypeMaxTimestamp is the maximum representable Timestamp value, which is the maximum 32-bit integer as a Unix time.
+	// datetimeTypeMaxTimestamp is the maximum representable Timestamp value, MYSQL: 2038-01-19 03:14:07.999999 (microseconds)
 	datetimeTypeMaxTimestamp = time.Unix(math.MaxInt32, 999999000)
 
-	// datetimeTypeMinTimestamp is the minimum representable Timestamp value, which is one second past the epoch.
+	// datetimeTypeMinTimestamp is the minimum representable Timestamp value, MYSQL: 1970-01-01 00:00:01.000000 (microseconds)
 	datetimeTypeMinTimestamp = time.Unix(1, 0)
 
+	datetimeTypeMaxDate = time.Date(9999, 12, 31, 0, 0, 0, 0, time.UTC)
+
+	// datetimeTypeMinDate is the minimum representable Date value, MYSQL: 1000-01-01 00:00:00.000000 (microseconds)
+	datetimeTypeMinDate = time.Date(1000, 1, 1, 0, 0, 0, 0, time.UTC)
+
+	// The MAX and MIN are extrapolated from commit ff05628a530 in the MySQL source code from my_time.cc
+	// datetimeMaxTime is the maximum representable time value, MYSQL: 9999-12-31 23:59:59.999999 (microseconds)
+	datetimeMaxTime = time.Date(9999, 12, 31, 23, 59, 59, 999999000, time.UTC)
+
+	// datetimeMinTime is the minimum representable time value, MYSQL: 0000-01-01 00:00:00.000000 (microseconds)
+	datetimeMinTime = time.Date(0000, 0, 0, 0, 0, 0, 0, time.UTC)
+
 	DateOnlyLayouts = []string{
 		"20060102",
 		"2006-1-2",
@@ -71,8 +83,9 @@ var (
 		"2006-01-02 15:04:",
 		"2006-01-02 15:04:.",
 		"2006-01-02 15:04:05.",
-		"2006-01-02 15:04:05.999999",
-		"2006-1-2 15:4:5.999999",
+		"2006-01-02 15:04:05.999999999",
+		"2006-1-2 15:4:5.999999999",
+		"2006-1-2:15:4:5.999999999",
 		"2006-01-02T15:04:05",
 		"20060102150405",
 		"2006-01-02 15:04:05.999999999 -0700 MST", // represents standard Time.time.UTC()
@@ -91,6 +104,8 @@ var (
 	Timestamp = MustCreateDatetimeType(sqltypes.Timestamp, 0)
 	// TimestampMaxPrecision is a UNIX timestamp with maximum precision
 	TimestampMaxPrecision = MustCreateDatetimeType(sqltypes.Timestamp, 6)
+	// DatetimeMaxRange is a date and a time with maximum precision and maximum range.
+	DatetimeMaxRange = MustCreateDatetimeType(sqltypes.Datetime, 6)
 
 	datetimeValueType = reflect.TypeOf(time.Time{})
 )
@@ -200,9 +215,20 @@ func ConvertToTime(ctx context.Context, v interface{}, t datetimeType) (time.Tim
 	}
 
 	// Round the date to the precision of this type
-	truncationDuration := time.Second
-	truncationDuration /= time.Duration(precisionConversion[t.precision])
-	res = res.Round(truncationDuration)
+	if t.precision < 6 {
+		truncationDuration := time.Second / time.Duration(precisionConversion[t.precision])
+		res = res.Round(truncationDuration)
+	} else {
+		res = res.Round(time.Microsecond)
+	}
+
+	if t == DatetimeMaxRange {
+		validated := ValidateTime(res)
+		if validated == nil {
+			return time.Time{}, ErrConvertingToTimeOutOfRange.New(v, t)
+		}
+		return validated.(time.Time), nil
+	}
 
 	switch t.baseType {
 	case sqltypes.Date:
@@ -214,10 +240,11 @@ func ConvertToTime(ctx context.Context, v interface{}, t datetimeType) (time.Tim
 			return time.Time{}, ErrConvertingToTimeOutOfRange.New(res.Format(sql.TimestampDatetimeLayout), t.String())
 		}
 	case sqltypes.Timestamp:
-		if res.Before(datetimeTypeMinTimestamp) || res.After(datetimeTypeMaxTimestamp) {
+		if ValidateTimestamp(res) == nil {
 			return time.Time{}, ErrConvertingToTimeOutOfRange.New(res.Format(sql.TimestampDatetimeLayout), t.String())
 		}
 	}
+
 	return res, nil
 }
 
@@ -338,8 +365,8 @@ func (t datetimeType) ConvertWithoutRangeCheck(ctx context.Context, v interface{
 }
 
 func parseDatetime(value string) (time.Time, bool) {
-	for _, fmt := range TimestampDatetimeLayouts {
-		if t, err := time.Parse(fmt, value); err == nil {
+	for _, layout := range TimestampDatetimeLayouts {
+		if t, err := time.Parse(layout, value); err == nil {
 			return t.UTC(), true
 		}
 	}
@@ -473,7 +500,16 @@ func (t datetimeType) MinimumTime() time.Time {
 // ValidateTime receives a time and returns either that time or nil if it's
 // not a valid time.
 func ValidateTime(t time.Time) interface{} {
-	if t.After(time.Date(9999, time.December, 31, 23, 59, 59, 999999999, time.UTC)) {
+	if t.Before(datetimeMinTime) || t.After(datetimeMaxTime) {
+		return nil
+	}
+	return t
+}
+
+// ValidateTimestamp receives a time and returns either that time or nil if it's
+// not a valid timestamp.
+func ValidateTimestamp(t time.Time) interface{} {
+	if t.Before(datetimeTypeMinTimestamp) || t.After(datetimeTypeMaxTimestamp) {
 		return nil
 	}
 	return t

sql/types/datetime_test.go

@@ -405,3 +405,35 @@ func TestDatetimeZero(t *testing.T) {
 	_, ok = MustCreateDatetimeType(sqltypes.Timestamp, 0).Zero().(time.Time)
 	require.True(t, ok)
 }
+
+func TestDatetimeOverflowUnderflow(t *testing.T) {
+	ctx := sql.NewEmptyContext()
+	tests := []struct {
+		typ         sql.DatetimeType
+		val         interface{}
+		expectError bool
+	}{
+		{Timestamp, "1969-12-31 23:59:59", true},
+		{Timestamp, "2038-01-19 03:14:08", true},
+		{Date, Date.MinimumTime().Format("2006-01-02"), false},
+		{Date, Date.MaximumTime().Format("2006-01-02"), false},
+		{Datetime, Datetime.MinimumTime().Format("2006-01-02 15:04:05"), false},
+		{Datetime, Datetime.MaximumTime().Format("2006-01-02 15:04:05"), false},
+		{Timestamp, Timestamp.MinimumTime().Format("2006-01-02 15:04:05"), false},
+		{Timestamp, Timestamp.MaximumTime().Format("2006-01-02 15:04:05"), false},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.typ.String()+"_"+tt.val.(string), func(t *testing.T) {
+			_, inRange, err := tt.typ.Convert(ctx, tt.val)
+
+			if tt.expectError {
+				require.True(t, err != nil || inRange == sql.OutOfRange,
+					"expected error or out-of-range but got neither; err: %v, inRange: %v", err, inRange)
+			} else {
+				require.NoError(t, err)
+				require.Equal(t, sql.InRange, inRange)
+			}
+		})
+	}
+}