pingcap · zz-jason · Aug 23, 2017 · Mar 21, 2017 · Mar 29, 2017 · Mar 31, 2017
diff --git a/ast/functions.go b/ast/functions.go
@@ -162,6 +162,7 @@ const (
 	WeekOfYear       = "weekofyear"
 	Year             = "year"
 	YearWeek         = "yearweek"
+	LastDay          = "last_day"
 
 	// string functions
 	ASCII           = "ascii"

diff --git a/expression/builtin.go b/expression/builtin.go
@@ -772,6 +772,7 @@ var funcs = map[string]functionClass{
 	ast.WeekOfYear:       &weekOfYearFunctionClass{baseFunctionClass{ast.WeekOfYear, 1, 1}},
 	ast.Year:             &yearFunctionClass{baseFunctionClass{ast.Year, 1, 1}},
 	ast.YearWeek:         &yearWeekFunctionClass{baseFunctionClass{ast.YearWeek, 1, 2}},
+	ast.LastDay:          &lastDayFunctionClass{baseFunctionClass{ast.LastDay, 1, 1}},
 
 	// string functions
 	ast.ASCII:           &asciiFunctionClass{baseFunctionClass{ast.ASCII, 1, 1}},

diff --git a/expression/builtin_time.go b/expression/builtin_time.go
@@ -101,6 +101,7 @@ var (
 	_ functionClass = &toSecondsFunctionClass{}
 	_ functionClass = &utcTimeFunctionClass{}
 	_ functionClass = &timestampFunctionClass{}
+	_ functionClass = &lastDayFunctionClass{}
 )
 
 var (
@@ -154,6 +155,7 @@ var (
 	_ builtinFunc = &builtinToSecondsSig{}
 	_ builtinFunc = &builtinUTCTimeSig{}
 	_ builtinFunc = &builtinTimestampSig{}
+	_ builtinFunc = &builtinLastDaySig{}
 )
 
 // handleInvalidTimeError reports error or warning depend on the context.
@@ -2981,9 +2983,6 @@ func (b *builtinToDaysSig) evalInt(row []types.Datum) (int64, bool, error) {
 	if isNull || err != nil {
 		return 0, true, errors.Trace(handleInvalidTimeError(b.ctx, err))
 	}
-	if err != nil {
-		return 0, true, errors.Trace(handleInvalidTimeError(b.ctx, err))
-	}
 	ret := types.TimestampDiff("DAY", types.ZeroDate, arg)
 	if ret == 0 {
 		return 0, true, errors.Trace(handleInvalidTimeError(b.ctx, types.ErrInvalidTimeFormat))
@@ -3018,9 +3017,6 @@ func (b *builtinToSecondsSig) evalInt(row []types.Datum) (int64, bool, error) {
 	if isNull || err != nil {
 		return 0, true, errors.Trace(handleInvalidTimeError(b.ctx, err))
 	}
-	if err != nil {
-		return 0, true, errors.Trace(handleInvalidTimeError(b.ctx, err))
-	}
 	ret := types.TimestampDiff("SECOND", types.ZeroDate, arg)
 	if ret == 0 {
 		return 0, true, errors.Trace(handleInvalidTimeError(b.ctx, types.ErrInvalidTimeFormat))
@@ -3063,3 +3059,54 @@ func (b *builtinUTCTimeSig) eval(row []types.Datum) (d types.Datum, err error) {
 	d.SetString(time.Now().UTC().Format(utctimeFormat))
 	return convertToDuration(b.ctx.GetSessionVars().StmtCtx, d, fsp)
 }
+
+type lastDayFunctionClass struct {
+	baseFunctionClass
+}
+
+func (c *lastDayFunctionClass) getFunction(args []Expression, ctx context.Context) (builtinFunc, error) {
+	if err := c.verifyArgs(args); err != nil {
+		return nil, errors.Trace(err)
+	}
+	bf, err := newBaseBuiltinFuncWithTp(args, ctx, tpTime, tpTime)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	bf.tp.Tp, bf.tp.Flen, bf.tp.Decimal = mysql.TypeDate, mysql.MaxDateWidth, types.DefaultFsp
+	sig := &builtinLastDaySig{baseTimeBuiltinFunc{bf}}
+	return sig.setSelf(sig), nil
+}
+
+type builtinLastDaySig struct {
+	baseTimeBuiltinFunc
+}
+
+// evalTime evals a builtinLastDaySig.
+// See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-functions.html#function_last-day
+func (b *builtinLastDaySig) evalTime(row []types.Datum) (types.Time, bool, error) {
+	sc := b.ctx.GetSessionVars().StmtCtx
+	arg, isNull, err := b.args[0].EvalTime(row, sc)
+	if isNull || err != nil {
+		return types.Time{}, true, errors.Trace(handleInvalidTimeError(b.ctx, err))
+	}
+	tm := arg.Time
+	year, month, day := tm.Year(), tm.Month(), 30
+	if year == 0 && month == 0 && tm.Day() == 0 {
+		return types.Time{}, true, errors.Trace(handleInvalidTimeError(b.ctx, types.ErrInvalidTimeFormat))
+	}
+	if month == 1 || month == 3 || month == 5 ||
+		month == 7 || month == 8 || month == 10 || month == 12 {
+		day = 31
+	} else if month == 2 {
+		day = 28
+		if tm.IsLeapYear() {
+			day = 29
+		}
+	}
+	ret := types.Time{
+		Time: types.FromDate(year, month, day, 0, 0, 0, 0),
+		Type: mysql.TypeDate,
+		Fsp:  types.DefaultFsp,
+	}
+	return ret, false, nil
+}
diff --git a/expression/builtin_time_test.go b/expression/builtin_time_test.go
@@ -1943,3 +1943,42 @@ func (s *testEvaluatorSuite) TestPeriodDiff(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(v.Kind(), Equals, types.KindNull)
 }
+
+func (s *testEvaluatorSuite) TestLastDay(c *C) {
+	tests := []struct {
+		param  interface{}
+		expect string
+	}{
+		{"2003-02-05", "2003-02-28"},
+		{"2004-02-05", "2004-02-29"},
+		{"2004-01-01 01:01:01", "2004-01-31"},
+		{950501, "1995-05-31"},
+	}
+
+	fc := funcs[ast.LastDay]
+	for _, test := range tests {
+		t := []types.Datum{types.NewDatum(test.param)}
+		f, err := fc.getFunction(datumsToConstants(t), s.ctx)
+		c.Assert(f.isDeterministic(), IsTrue)
+		c.Assert(err, IsNil)
+		d, err := f.eval(nil)
+		c.Assert(err, IsNil)
+		result, _ := d.ToString()
+		c.Assert(result, Equals, test.expect)
+	}
+
+	testsNull := []interface{}{
+		"0000-00-00",
+		"1992-13-00",
+		"2007-10-07 23:59:61",
+		123456789}
+
+	for _, i := range testsNull {
+		t := []types.Datum{types.NewDatum(i)}
+		f, err := fc.getFunction(datumsToConstants(t), s.ctx)
+		c.Assert(f.isDeterministic(), IsTrue)
+		c.Assert(err, IsNil)
+		d, err := f.eval(nil)
+		c.Assert(d.IsNull(), IsTrue)
+	}
+}
diff --git a/expression/integration_test.go b/expression/integration_test.go
@@ -1061,6 +1061,17 @@ func (s *testIntegrationSuite) TestTimeBuiltin(c *C) {
 	result.Check(testkit.Rows("62966505600 63426672000 63426721412 63426721412"))
 	result = tk.MustQuery("select to_days(950501), to_days('2007-10-07'), to_days('2007-10-07 00:00:59'), to_days('0000-01-01')")
 	result.Check(testkit.Rows("728779 733321 733321 1"))
+	result = tk.MustQuery("select last_day('2003-02-05'), last_day('2004-02-05'), last_day('2004-01-01 01:01:01'), last_day(950501);")
+	result.Check(testkit.Rows("2003-02-28 2004-02-29 2004-01-31 1995-05-31"))
+
+	tk.MustExec("SET SQL_MODE='';")
+	result = tk.MustQuery("select last_day('0000-00-00');")
+	result.Check(testkit.Rows("<nil>"))
+	result = tk.MustQuery("select to_days('0000-00-00');")
+	result.Check(testkit.Rows("<nil>"))
+	result = tk.MustQuery("select to_seconds('0000-00-00');")
+	result.Check(testkit.Rows("<nil>"))
+
 	result = tk.MustQuery("select TIMESTAMPDIFF(MONTH,'2003-02-01','2003-05-01'), TIMESTAMPDIFF(yEaR,'2002-05-01', " +
 		"'2001-01-01'), TIMESTAMPDIFF(minute,binary('2003-02-01'),'2003-05-01 12:05:55'), TIMESTAMPDIFF(day," +
 		"'1995-05-02', 950501);")

diff --git a/expression/typeinferer.go b/expression/typeinferer.go
@@ -372,7 +372,7 @@ func (v *typeInferrer) handleFuncCallExpr(x *ast.FuncCallExpr) {
 	case ast.Curtime, ast.CurrentTime, ast.TimeDiff, ast.MakeTime, ast.SecToTime, ast.UTCTime, ast.Time:
 		tp = types.NewFieldType(mysql.TypeDuration)
 		tp.Decimal = v.getFsp(x)
-	case ast.Curdate, ast.CurrentDate, ast.Date, ast.FromDays, ast.MakeDate:
+	case ast.Curdate, ast.CurrentDate, ast.Date, ast.FromDays, ast.MakeDate, ast.LastDay:
 		tp = types.NewFieldType(mysql.TypeDate)
 	case ast.DateAdd, ast.DateSub, ast.AddDate, ast.SubDate, ast.Timestamp, ast.TimestampAdd, ast.StrToDate, ast.ConvertTz:
 		tp = types.NewFieldType(mysql.TypeDatetime)

diff --git a/parser/misc.go b/parser/misc.go
@@ -465,6 +465,7 @@ var tokenMap = map[string]int{
 	"TO_BASE64":                  toBase64,
 	"TO_DAYS":                    toDays,
 	"TO_SECONDS":                 toSeconds,
+	"LAST_DAY":                   lastDay,
 	"TRAILING":                   trailing,
 	"TRANSACTION":                transaction,
 	"TRIGGER":                    trigger,

diff --git a/parser/parser.y b/parser/parser.y
@@ -372,6 +372,7 @@ import (
 	toBase64			"TO_BASE64"
 	toDays				"TO_DAYS"
 	toSeconds			"TO_SECONDS"
+	lastDay			    "LAST_DAY"
 	getLock				"GET_LOCK"
 	releaseLock			"RELEASE_LOCK"
 	rpad				"RPAD"
@@ -2459,7 +2460,7 @@ NotKeywordToken:
 	"QUOTE" | "SEC_TO_TIME" | "SECOND" | "SIGN" | "SIN" | "SLEEP" | "SQRT" | "SQL_CALC_FOUND_ROWS" | "STR_TO_DATE" | "SUBTIME" | "SUBDATE" | "SUBSTRING" %prec lowerThanLeftParen |
 	"SESSION_USER" | "SUBSTRING_INDEX" | "SUM" | "SYSTEM_USER" | "TAN" | "TIME_FORMAT" | "TIME_TO_SEC" | "TIMESTAMPADD" | "TO_BASE64" | "TO_DAYS" | "TO_SECONDS" | "TRIM" | "RTRIM" | "UCASE" | "UTC_TIME" | "UPPER" | "VERSION" | "WEEKDAY" | "WEEKOFYEAR" | "YEARWEEK" | "ROUND"
 |	"STATS_PERSISTENT" | "GET_LOCK" | "RELEASE_LOCK" | "CEIL" | "CEILING" | "FLOOR" | "FROM_UNIXTIME" | "TIMEDIFF" | "LN" | "LOG" | "LOG2" | "LOG10" | "FIELD_KWD"
-|	"AES_DECRYPT" | "AES_ENCRYPT" | "QUOTE"
+|	"AES_DECRYPT" | "AES_ENCRYPT" | "QUOTE" | "LAST_DAY"
 |	"ANY_VALUE" | "INET_ATON" | "INET_NTOA" | "INET6_ATON" | "INET6_NTOA" | "IS_FREE_LOCK" | "IS_IPV4" | "IS_IPV4_COMPAT" | "IS_IPV4_MAPPED" | "IS_IPV6" | "IS_USED_LOCK" | "MASTER_POS_WAIT" | "NAME_CONST" | "RELEASE_ALL_LOCKS" | "UUID" | "UUID_SHORT"
 |	"COMPRESS" | "DECODE" | "DES_DECRYPT" | "DES_ENCRYPT" | "ENCODE" | "ENCRYPT" | "MD5" | "OLD_PASSWORD" | "RANDOM_BYTES" | "SHA1" | "SHA" | "SHA2" | "UNCOMPRESS" | "UNCOMPRESSED_LENGTH" | "VALIDATE_PASSWORD_STRENGTH"
 |	"JSON_EXTRACT" | "JSON_UNQUOTE" | "JSON_TYPE" | "JSON_MERGE" | "JSON_SET" | "JSON_INSERT" | "JSON_REPLACE" | "JSON_REMOVE" | "JSON_OBJECT" | "JSON_ARRAY" | "TIDB_VERSION"
@@ -3563,6 +3564,10 @@ FunctionCallNonKeyword:
 	{
 		$$ = &ast.FuncCallExpr{FnName: model.NewCIStr($1), Args: $3.([]ast.ExprNode)}
 	}
+|	"LAST_DAY" '(' ExpressionListOpt ')'
+	{
+		$$ = &ast.FuncCallExpr{FnName: model.NewCIStr($1), Args: $3.([]ast.ExprNode)}
+	}
 |	"TRIM" '(' Expression ')'
 	{
 		$$ = &ast.FuncCallExpr{

diff --git a/parser/parser_test.go b/parser/parser_test.go
@@ -792,6 +792,9 @@ func (s *testParserSuite) TestBuiltin(c *C) {
 		{"SELECT TO_DAYS('2007-10-07')", true},
 		{"SELECT TO_SECONDS('2009-11-29')", true},
 
+		// for LAST_DAY
+		{"SELECT LAST_DAY('2003-02-05');", true},
+
 		// for UTC_TIME
 		{"SELECT UTC_TIME(), UTC_TIME(1)", true},
 

diff --git a/plan/typeinfer_test.go b/plan/typeinfer_test.go
@@ -1192,6 +1192,16 @@ func (s *testPlanSuite) createTestCase4TimeFuncs() []typeInferTestCase {
 		{"microsecond(c_set        )", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 6, 0},
 		{"microsecond(c_enum       )", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 6, 0},
 
+		{"last_day(c_datetime)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_datetime_d)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_timestamp)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_timestamp_d)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_char)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_varchar)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_varchar)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_text_d)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+		{"last_day(c_blob_d)", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, mysql.MaxDateWidth, 0},
+
 		{"week(c_int_d      )", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 2, 0},
 		{"week(c_bigint_d   )", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 2, 0},
 		{"week(c_float_d    )", mysql.TypeLonglong, charset.CharsetBin, mysql.BinaryFlag, 2, 0},

diff --git a/util/types/mytime.go b/util/types/mytime.go
@@ -103,6 +103,10 @@ func (t mysqlTime) GoTime(loc *gotime.Location) (gotime.Time, error) {
 	return tm, nil
 }
 
+func (t mysqlTime) IsLeapYear() bool {
+	return (t.year%4 == 0 && t.year%100 != 0) || t.year%400 == 0
+}
+
 func newMysqlTime(year, month, day, hour, minute, second, microsecond int) mysqlTime {
 	return mysqlTime{
 		uint16(year),

diff --git a/util/types/mytime_test.go b/util/types/mytime_test.go
@@ -179,3 +179,28 @@ func (s *testMyTimeSuite) TestMixDateAndTime(c *C) {
 		c.Assert(compareTime(&t.date, &t.expect), Equals, 0, Commentf("%d", ith))
 	}
 }
+
+func (s *testMyTimeSuite) TestIsLeapYear(c *C) {
+	tests := []struct {
+		T      mysqlTime
+		Expect bool
+	}{
+		{mysqlTime{1960, 1, 1, 0, 0, 0, 0}, true},
+		{mysqlTime{1963, 2, 21, 0, 0, 0, 0}, false},
+		{mysqlTime{2008, 11, 25, 0, 0, 0, 0}, true},
+		{mysqlTime{2017, 4, 24, 0, 0, 0, 0}, false},
+		{mysqlTime{1988, 2, 29, 0, 0, 0, 0}, true},
+		{mysqlTime{2000, 3, 15, 0, 0, 0, 0}, true},
+		{mysqlTime{1992, 5, 3, 0, 0, 0, 0}, true},
+		{mysqlTime{2024, 10, 1, 0, 0, 0, 0}, true},
+		{mysqlTime{2016, 6, 29, 0, 0, 0, 0}, true},
+		{mysqlTime{2015, 6, 29, 0, 0, 0, 0}, false},
+		{mysqlTime{2014, 9, 31, 0, 0, 0, 0}, false},
+		{mysqlTime{2001, 12, 7, 0, 0, 0, 0}, false},
+		{mysqlTime{1989, 7, 6, 0, 0, 0, 0}, false},
+	}
+
+	for _, tt := range tests {
+		c.Assert(tt.T.IsLeapYear(), Equals, tt.Expect)
+	}
+}
diff --git a/util/types/time.go b/util/types/time.go
@@ -135,6 +135,7 @@ type TimeInternal interface {
 	Week(mode int) int
 	Microsecond() int
 	GoTime(*gotime.Location) (gotime.Time, error)
+	IsLeapYear() bool
 }
 
 // FromGoTime translates time.Time to mysql time internal representation.