parser, ast, expression: fix bug on DATE literal

ast/functions.go

@@ -112,6 +112,7 @@ const (
 	CurrentTimestamp = "current_timestamp"
 	Curtime          = "curtime"
 	Date             = "date"
+	DateLiteral      = "dateliteral"
 	DateAdd          = "date_add"
 	DateFormat       = "date_format"
 	DateSub          = "date_sub"

expression/builtin.go

@@ -738,6 +738,7 @@ var funcs = map[string]functionClass{
 	ast.CurrentTimestamp: &nowFunctionClass{baseFunctionClass{ast.CurrentTimestamp, 0, 1}},
 	ast.Curtime:          &currentTimeFunctionClass{baseFunctionClass{ast.Curtime, 0, 1}},
 	ast.Date:             &dateFunctionClass{baseFunctionClass{ast.Date, 1, 1}},
+	ast.DateLiteral:      &dateLiteralFunctionClass{baseFunctionClass{ast.DateLiteral, 1, 1}},
 	ast.DateAdd:          &dateArithFunctionClass{baseFunctionClass{ast.DateAdd, 3, 3}, ast.DateArithAdd},
 	ast.DateFormat:       &dateFormatFunctionClass{baseFunctionClass{ast.DateFormat, 2, 2}},
 	ast.DateSub:          &dateArithFunctionClass{baseFunctionClass{ast.DateSub, 3, 3}, ast.DateArithSub},

expression/builtin_time.go

@@ -53,8 +53,12 @@ const ( // GET_FORMAT location.
 // DurationPattern determine whether to match the format of duration.
 var DurationPattern = regexp.MustCompile(`^(|[-]?)(|\d{1,2}\s)(\d{2,3}:\d{2}:\d{2}|\d{1,2}:\d{2}|\d{1,6})(|\.\d*)$`)
 
+// DatePattern determine whether to match the format of date.
+var DatePattern = regexp.MustCompile(`^\s*((0*\d{1,4}([^\d]0*\d{1,2}){2})|(\d{2,4}(\d{2}){2}))\s*$`)
+
 var (
 	_ functionClass = &dateFunctionClass{}
+	_ functionClass = &dateLiteralFunctionClass{}
 	_ functionClass = &dateDiffFunctionClass{}
 	_ functionClass = &timeDiffFunctionClass{}
 	_ functionClass = &dateFormatFunctionClass{}
@@ -107,6 +111,7 @@ var (
 
 var (
 	_ builtinFunc = &builtinDateSig{}
+	_ builtinFunc = &builtinDateLiteralSig{}
 	_ builtinFunc = &builtinDateDiffSig{}
 	_ builtinFunc = &builtinTimeDiffSig{}
 	_ builtinFunc = &builtinDateFormatSig{}
@@ -283,6 +288,58 @@ func (b *builtinDateSig) evalTime(row []types.Datum) (types.Time, bool, error) {
 	return expr, false, nil
 }
 
+type dateLiteralFunctionClass struct {
+	baseFunctionClass
+}
+
+func (c *dateLiteralFunctionClass) getFunction(ctx context.Context, args []Expression) (builtinFunc, error) {
+	if err := c.verifyArgs(args); err != nil {
+		return nil, errors.Trace(err)
+	}
+	constant, ok := args[0].(*Constant)
+	if !ok {
+		return nil, errors.Trace(types.ErrInvalidTimeFormat)
+	}
+	str := constant.Value.GetString()
+	if !DatePattern.MatchString(str) {
+		return nil, errors.Trace(types.ErrInvalidTimeFormat)
+	}
+	tm, err := types.ParseDate(str)
+	if err != nil {
+		return nil, errors.Trace(err)
+	}
+	bf := newBaseBuiltinFuncWithTp(args, ctx, tpDatetime, tpString)
+	bf.tp.Tp, bf.tp.Flen, bf.tp.Decimal = mysql.TypeDate, 10, 0
+	sig := &builtinDateLiteralSig{baseTimeBuiltinFunc{bf}, tm}
+	return sig.setSelf(sig), nil
+}
+
+type builtinDateLiteralSig struct {
+	baseTimeBuiltinFunc
+	tm types.Time
+}
+
+// evalTime evals DATE 'stringLit'.
+// See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-literals.html
+func (b *builtinDateLiteralSig) evalTime(row []types.Datum) (types.Time, bool, error) {
+	/*
+		sc := b.ctx.GetSessionVars().StmtCtx
+		str, isNull, err := b.args[0].EvalString(row, sc)
+		if isNull || err != nil {
+			return types.Time{}, true, errors.Trace(err)
+		}
+		if !DatePattern.MatchString(str) {
+			return types.Time{}, true, errors.Trace(types.ErrInvalidTimeFormat)
+		}
+		ret, err := types.ParseDate(str)
+		if err != nil {
+			return types.Time{}, true, errors.Trace(err)
+		}
+		return ret, false, nil
+	*/
+	return b.tm, false, nil
+}
+
 func convertDatumToTime(sc *variable.StatementContext, d types.Datum) (t types.Time, err error) {
 	if d.Kind() != types.KindMysqlTime {
 		d, err = convertToTime(sc, d, mysql.TypeDatetime)

expression/integration_test.go

@@ -2422,21 +2422,34 @@ func (s *testIntegrationSuite) TestDateBuiltin(c *C) {
 	r = tk.MustQuery("select date'2017/12-12'")
 	r.Check(testkit.Rows("2017-12-12"))
 
-	r = tk.MustQuery("select date'0000-00-00'")
-	r.Check(testkit.Rows("<nil>"))
+	r = tk.MustQuery("select date '0000-00-00';")
+	r.Check(testkit.Rows("0000-00-00"))
 
-	r = tk.MustQuery("select date'0000-00-00 00:00:00'")
-	r.Check(testkit.Rows("<nil>"))
+	r = tk.MustQuery("select date'1998~01~02'")
+	r.Check(testkit.Rows("1998-01-02"))
 
-	r = tk.MustQuery("select date'2017-99-99';")
-	r.Check(testkit.Rows("<nil>"))
+	r = tk.MustQuery("select date'731124', date '011124'")
+	r.Check(testkit.Rows("1973-11-24 2001-11-24"))
 
-	r = tk.MustQuery("select date'2017-2-31';")
-	r.Check(testkit.Rows("<nil>"))
+	_, err := tk.Exec("select date '0000-00-00 00:00:00';")
+	c.Assert(err, NotNil)
+	c.Assert(terror.ErrorEqual(err, types.ErrInvalidTimeFormat), IsTrue)
+
+	_, err = tk.Exec("select date '2017-99-99';")
+	c.Assert(err, NotNil)
+	c.Assert(terror.ErrorEqual(err, types.ErrInvalidTimeFormat), IsTrue)
+
+	_, err = tk.Exec("select date '2017-2-31';")
+	c.Assert(err, NotNil)
+	c.Assert(terror.ErrorEqual(err, types.ErrInvalidTimeFormat), IsTrue)
 
-	r = tk.MustQuery("select date'201712-31';")
-	r.Check(testkit.Rows("<nil>"))
+	_, err = tk.Exec("select date '201712-31';")
+	c.Assert(err, NotNil)
+	c.Assert(terror.ErrorEqual(err, types.ErrInvalidTimeFormat), IsTrue)
 
+	_, err = tk.Exec("select date 'abcdefg';")
+	c.Assert(err, NotNil)
+	c.Assert(terror.ErrorEqual(err, types.ErrInvalidTimeFormat), IsTrue)
 }
 
 func (s *testIntegrationSuite) TestLiterals(c *C) {

parser/parser.y

@@ -2892,7 +2892,7 @@ FunctionCallConflict:
 |	"DATE"  stringLit
 	{
 		expr := ast.NewValueExpr($2)
-		$$ = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.Date), Args: []ast.ExprNode{expr}}
+		$$ = &ast.FuncCallExpr{FnName: model.NewCIStr(ast.DateLiteral), Args: []ast.ExprNode{expr}}
 	}
 
 DistinctKwd:

plan/typeinfer_test.go

@@ -1782,6 +1782,12 @@ func (s *testPlanSuite) createTestCase4LikeFuncs() []typeInferTestCase {
 	}
 }
 
+func (s *testPlanSuite) createTestCase4Literals() []typeInferTestCase {
+	return []typeInferTestCase{
+		{"date '2017-01-01'", mysql.TypeDate, charset.CharsetBin, mysql.BinaryFlag, 0, 10},
+	}
+}
+
 func (s *testPlanSuite) createTestCase4JSONFuncs() []typeInferTestCase {
 	return []typeInferTestCase{
 		{"json_type(c_json)", mysql.TypeVarString, charset.CharsetUTF8, 0, 51, types.UnspecifiedLength},