fix leap year errs

fix err in existing test

Author: elianddb

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.DatetimeMaxLimit.Convert(ctx, date)
 	if err != nil {
 		ctx.Warn(1292, err.Error())
 		return nil, nil

sql/expression/interval.go

@@ -237,15 +237,62 @@ const (
 	week = 7 * day
 )
 
+// isLeapYear determines if a given year is a leap year
+// Uses Go's built-in date handling for accuracy
+func isLeapYear(year int) bool {
+	return daysInMonth(year, time.February) == 29
+}
+
+// daysInMonth returns the number of days in a given month/year combination
+// Uses Go's built-in date handling: day 0 of next month = last day of current month
+func daysInMonth(year int, month time.Month) int {
+	return time.Date(year, month+1, 0, 0, 0, 0, 0, time.UTC).Day()
+}
+
 func (td TimeDelta) apply(t time.Time, sign int64) time.Time {
-	// add years, months, days using AddDate (handles normalization)
-	t = t.AddDate(
-		int(td.Years*sign),
-		int(td.Months*sign),
-		int(td.Days*sign),
-	)
-
-	// add hours, minutes, seconds, microseconds
+	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 {
+			t = time.Date(targetYear, t.Month(), t.Day(),
+				t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+		}
+	}
+
+	if td.Months != 0 {
+		totalMonths := int(t.Month()) - 1 + int(td.Months*sign) // Convert to 0-based
+
+		// 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
+
+		// Handle end-of-month edge cases
+		originalDay := t.Day()
+		maxDaysInTargetMonth := daysInMonth(targetYear, targetMonth)
+
+		targetDay := originalDay
+		if originalDay > maxDaysInTargetMonth {
+			targetDay = maxDaysInTargetMonth
+		}
+
+		t = time.Date(targetYear, targetMonth, targetDay,
+			t.Hour(), t.Minute(), t.Second(), t.Nanosecond(), t.Location())
+	}
+
+	if td.Days != 0 {
+		t = t.AddDate(0, 0, int(td.Days*sign))
+	}
+
 	duration := time.Duration(td.Hours*sign)*time.Hour +
 		time.Duration(td.Minutes*sign)*time.Minute +
 		time.Duration(td.Seconds*sign)*time.Second +

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/types/datetime.go

@@ -103,6 +103,8 @@ var (
 	Timestamp = MustCreateDatetimeType(sqltypes.Timestamp, 0)
 	// TimestampMaxPrecision is a UNIX timestamp with maximum precision
 	TimestampMaxPrecision = MustCreateDatetimeType(sqltypes.Timestamp, 6)
+	// DatetimeMaxLimit is a date and a time with maximum precision and maximum range.
+	DatetimeMaxLimit = MustCreateDatetimeType(sqltypes.Datetime, 6)
 
 	datetimeValueType = reflect.TypeOf(time.Time{})
 )
@@ -207,11 +209,34 @@ func ConvertToTime(ctx context.Context, v interface{}, t datetimeType) (time.Tim
 		return time.Time{}, err
 	}
 
+	if t == DatetimeMaxLimit {
+		validated := ValidateTime(res)
+		if validated == nil {
+			return time.Time{}, ErrConvertingToTimeOutOfRange.New(v, t)
+		}
+		return validated.(time.Time), nil
+	}
+
+	switch t.baseType {
+	case sqltypes.Date:
+		if ValidateDate(res) == nil {
+			return time.Time{}, ErrConvertingToTimeOutOfRange.New(v, t)
+		}
+	case sqltypes.Datetime:
+		if ValidateDatetime(res) == nil {
+			return time.Time{}, ErrConvertingToTimeOutOfRange.New(v, t)
+		}
+	case sqltypes.Timestamp:
+		if ValidateTimestamp(res) == nil {
+			return time.Time{}, ErrConvertingToTimeOutOfRange.New(v, t)
+		}
+	}
+
 	if res.Equal(zeroTime) {
 		return zeroTime, nil
 	}
 
-	return res.Round(time.Microsecond), nil
+	return res, nil
 }
 
 // ConvertWithoutRangeCheck converts the parameter to time.Time without checking the range.
@@ -234,6 +259,7 @@ func (t datetimeType) ConvertWithoutRangeCheck(ctx context.Context, v interface{
 		// TODO: consider not using time.Parse if we want to match MySQL exactly ('2010-06-03 11:22.:.:.:.:' is a valid timestamp)
 		var parsed bool
 		res, parsed = parseDatetime(value)
+		res = res.Round(time.Microsecond)
 		if !parsed {
 			return zeroTime, ErrConvertingToTime.New(v)
 		}
@@ -469,7 +495,6 @@ func ValidateTime(t time.Time) interface{} {
 	if t.Before(datetimeMinTime) || t.After(datetimeMaxTime) {
 		return nil
 	}
-
 	return t
 }