From bfc4792e80c56e3cd9481b14eb3be7a8515ed307 Mon Sep 17 00:00:00 2001 From: Chao Wang Date: Tue, 14 Nov 2023 11:07:33 +0800 Subject: [PATCH] types: remove param `explicitTz` from `types.ParseTime` --- br/pkg/task/backup.go | 2 +- pkg/ddl/ddl_api.go | 2 +- pkg/executor/brie.go | 2 +- pkg/executor/inspection_result_test.go | 10 ++-- pkg/executor/inspection_summary_test.go | 2 +- .../calibrate_resource_test.go | 2 +- pkg/expression/builtin_cast.go | 4 +- pkg/expression/builtin_cast_vec.go | 4 +- pkg/expression/builtin_time.go | 14 ++--- pkg/expression/builtin_time_vec.go | 4 +- pkg/expression/helper.go | 17 +++--- .../handler/optimizor/statistics_handler.go | 2 +- pkg/server/internal/column/column_test.go | 2 +- pkg/sessionctx/variable/varsutil.go | 4 +- pkg/types/convert.go | 2 +- pkg/types/convert_test.go | 6 +- pkg/types/datum.go | 8 +-- pkg/types/datum_test.go | 6 +- pkg/types/format_test.go | 2 +- pkg/types/time.go | 60 +++++++------------ pkg/types/time_test.go | 38 ++++++------ pkg/util/codec/codec_test.go | 2 +- pkg/util/dbutil/common.go | 2 +- pkg/util/rowcodec/rowcodec_test.go | 2 +- 24 files changed, 92 insertions(+), 107 deletions(-) diff --git a/br/pkg/task/backup.go b/br/pkg/task/backup.go index 725efe75f7e74..89c3a1e3c4fc6 100644 --- a/br/pkg/task/backup.go +++ b/br/pkg/task/backup.go @@ -770,7 +770,7 @@ func ParseTSString(ts string, tzCheck bool) (uint64, error) { return 0, errors.Errorf("must set timezone when using datetime format ts, e.g. '2018-05-11 01:42:23+0800'") } } - t, err := types.ParseTime(sc.TypeCtx(), ts, mysql.TypeTimestamp, types.MaxFsp, nil) + t, err := types.ParseTime(sc.TypeCtx(), ts, mysql.TypeTimestamp, types.MaxFsp) if err != nil { return 0, errors.Trace(err) } diff --git a/pkg/ddl/ddl_api.go b/pkg/ddl/ddl_api.go index 2c0415196227b..ea7c6a8c046a1 100644 --- a/pkg/ddl/ddl_api.go +++ b/pkg/ddl/ddl_api.go @@ -1043,7 +1043,7 @@ func convertTimestampDefaultValToUTC(ctx sessionctx.Context, defaultVal interfac } if vv, ok := defaultVal.(string); ok { if vv != types.ZeroDatetimeStr && !strings.EqualFold(vv, ast.CurrentTimestamp) { - t, err := types.ParseTime(ctx.GetSessionVars().StmtCtx.TypeCtx(), vv, col.GetType(), col.GetDecimal(), nil) + t, err := types.ParseTime(ctx.GetSessionVars().StmtCtx.TypeCtx(), vv, col.GetType(), col.GetDecimal()) if err != nil { return defaultVal, errors.Trace(err) } diff --git a/pkg/executor/brie.go b/pkg/executor/brie.go index 953d725225a20..b4c3577e0adff 100644 --- a/pkg/executor/brie.go +++ b/pkg/executor/brie.go @@ -236,7 +236,7 @@ func (bq *brieQueue) clearTask(sc *stmtctx.StatementContext) { func (b *executorBuilder) parseTSString(ts string) (uint64, error) { sc := stmtctx.NewStmtCtxWithTimeZone(b.ctx.GetSessionVars().Location()) - t, err := types.ParseTime(sc.TypeCtx(), ts, mysql.TypeTimestamp, types.MaxFsp, nil) + t, err := types.ParseTime(sc.TypeCtx(), ts, mysql.TypeTimestamp, types.MaxFsp) if err != nil { return 0, err } diff --git a/pkg/executor/inspection_result_test.go b/pkg/executor/inspection_result_test.go index 462290347e446..f144ec0e0e632 100644 --- a/pkg/executor/inspection_result_test.go +++ b/pkg/executor/inspection_result_test.go @@ -179,7 +179,7 @@ func TestInspectionResult(t *testing.T) { } func parseTime(t *testing.T, se session.Session, str string) types.Time { - time, err := types.ParseTime(se.GetSessionVars().StmtCtx.TypeCtx(), str, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(se.GetSessionVars().StmtCtx.TypeCtx(), str, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } @@ -338,7 +338,7 @@ func TestThresholdCheckInspection2(t *testing.T) { tk := testkit.NewTestKit(t, store) tk.MustExec("use test") datetime := func(s string) types.Time { - time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } @@ -421,7 +421,7 @@ func TestThresholdCheckInspection3(t *testing.T) { tk := testkit.NewTestKit(t, store) tk.MustExec("use test") datetime := func(s string) types.Time { - time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } @@ -628,7 +628,7 @@ func TestNodeLoadInspection(t *testing.T) { tk := testkit.NewTestKit(t, store) tk.MustExec("use test") datetime := func(s string) types.Time { - time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } @@ -704,7 +704,7 @@ func TestConfigCheckOfStorageBlockCacheSize(t *testing.T) { tk := testkit.NewTestKit(t, store) tk.MustExec("use test") datetime := func(s string) types.Time { - time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } diff --git a/pkg/executor/inspection_summary_test.go b/pkg/executor/inspection_summary_test.go index e36cc44db715c..25e84b77c2589 100644 --- a/pkg/executor/inspection_summary_test.go +++ b/pkg/executor/inspection_summary_test.go @@ -51,7 +51,7 @@ func TestInspectionSummary(t *testing.T) { defer func() { require.NoError(t, failpoint.Disable(fpName)) }() datetime := func(s string) types.Time { - time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } diff --git a/pkg/executor/internal/calibrateresource/calibrate_resource_test.go b/pkg/executor/internal/calibrateresource/calibrate_resource_test.go index af3a017fcb1ae..40b0d78da967d 100644 --- a/pkg/executor/internal/calibrateresource/calibrate_resource_test.go +++ b/pkg/executor/internal/calibrateresource/calibrate_resource_test.go @@ -87,7 +87,7 @@ func TestCalibrateResource(t *testing.T) { }() datetime := func(s string) types.Time { - time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp, nil) + time, err := types.ParseTime(tk.Session().GetSessionVars().StmtCtx.TypeCtx(), s, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) return time } diff --git a/pkg/expression/builtin_cast.go b/pkg/expression/builtin_cast.go index 05d7bef7c707c..e0758061fcbc5 100644 --- a/pkg/expression/builtin_cast.go +++ b/pkg/expression/builtin_cast.go @@ -1481,7 +1481,7 @@ func (b *builtinCastStringAsTimeSig) evalTime(_ sessionctx.Context, row chunk.Ro return res, isNull, err } sc := b.ctx.GetSessionVars().StmtCtx - res, err = types.ParseTime(sc.TypeCtx(), val, b.tp.GetType(), b.tp.GetDecimal(), nil) + res, err = types.ParseTime(sc.TypeCtx(), val, b.tp.GetType(), b.tp.GetDecimal()) if err != nil { return types.ZeroTime, true, handleInvalidTimeError(b.ctx, err) } @@ -1960,7 +1960,7 @@ func (b *builtinCastJSONAsTimeSig) evalTime(_ sessionctx.Context, row chunk.Row) return res, false, err } sc := b.ctx.GetSessionVars().StmtCtx - res, err = types.ParseTime(sc.TypeCtx(), s, b.tp.GetType(), b.tp.GetDecimal(), nil) + res, err = types.ParseTime(sc.TypeCtx(), s, b.tp.GetType(), b.tp.GetDecimal()) if err != nil { return types.ZeroTime, true, handleInvalidTimeError(b.ctx, err) } diff --git a/pkg/expression/builtin_cast_vec.go b/pkg/expression/builtin_cast_vec.go index 73a104fb98153..5c2e30a2bde15 100644 --- a/pkg/expression/builtin_cast_vec.go +++ b/pkg/expression/builtin_cast_vec.go @@ -531,7 +531,7 @@ func (b *builtinCastJSONAsTimeSig) vecEvalTime(ctx sessionctx.Context, input *ch if err != nil { return err } - tm, err := types.ParseTime(stmtCtx.TypeCtx(), s, b.tp.GetType(), fsp, nil) + tm, err := types.ParseTime(stmtCtx.TypeCtx(), s, b.tp.GetType(), fsp) if err != nil { if err = handleInvalidTimeError(b.ctx, err); err != nil { return err @@ -1770,7 +1770,7 @@ func (b *builtinCastStringAsTimeSig) vecEvalTime(ctx sessionctx.Context, input * if result.IsNull(i) { continue } - tm, err := types.ParseTime(stmtCtx.TypeCtx(), buf.GetString(i), b.tp.GetType(), fsp, nil) + tm, err := types.ParseTime(stmtCtx.TypeCtx(), buf.GetString(i), b.tp.GetType(), fsp) if err != nil { if errors.Is(err, strconv.ErrSyntax) || errors.Is(err, strconv.ErrRange) { err = types.ErrIncorrectDatetimeValue.GenWithStackByArgs(buf.GetString(i)) diff --git a/pkg/expression/builtin_time.go b/pkg/expression/builtin_time.go index a62acec89f00f..4d14b07644fe7 100644 --- a/pkg/expression/builtin_time.go +++ b/pkg/expression/builtin_time.go @@ -2774,7 +2774,7 @@ func (du *baseDateArithmetical) getDateFromString(ctx sessionctx.Context, args [ } sc := ctx.GetSessionVars().StmtCtx - date, err := types.ParseTime(sc.TypeCtx(), dateStr, dateTp, types.MaxFsp, nil) + date, err := types.ParseTime(sc.TypeCtx(), dateStr, dateTp, types.MaxFsp) if err != nil { err = handleInvalidTimeError(ctx, err) if err != nil { @@ -3184,7 +3184,7 @@ func (du *baseDateArithmetical) vecGetDateFromString(b *baseBuiltinFunc, input * dateTp = mysql.TypeDatetime } - date, err := types.ParseTime(sc.TypeCtx(), dateStr, dateTp, types.MaxFsp, nil) + date, err := types.ParseTime(sc.TypeCtx(), dateStr, dateTp, types.MaxFsp) if err != nil { err = handleInvalidTimeError(b.ctx, err) if err != nil { @@ -4357,7 +4357,7 @@ func (b *builtinTimestamp1ArgSig) evalTime(ctx sessionctx.Context, row chunk.Row if b.isFloat { tm, err = types.ParseTimeFromFloatString(sc.TypeCtx(), s, mysql.TypeDatetime, types.GetFsp(s)) } else { - tm, err = types.ParseTime(sc.TypeCtx(), s, mysql.TypeDatetime, types.GetFsp(s), nil) + tm, err = types.ParseTime(sc.TypeCtx(), s, mysql.TypeDatetime, types.GetFsp(s)) } if err != nil { return types.ZeroTime, true, handleInvalidTimeError(b.ctx, err) @@ -4389,7 +4389,7 @@ func (b *builtinTimestamp2ArgsSig) evalTime(ctx sessionctx.Context, row chunk.Ro if b.isFloat { tm, err = types.ParseTimeFromFloatString(sc.TypeCtx(), arg0, mysql.TypeDatetime, types.GetFsp(arg0)) } else { - tm, err = types.ParseTime(sc.TypeCtx(), arg0, mysql.TypeDatetime, types.GetFsp(arg0), nil) + tm, err = types.ParseTime(sc.TypeCtx(), arg0, mysql.TypeDatetime, types.GetFsp(arg0)) } if err != nil { return types.ZeroTime, true, handleInvalidTimeError(b.ctx, err) @@ -4440,7 +4440,7 @@ func (c *timestampLiteralFunctionClass) getFunction(ctx sessionctx.Context, args if !timestampPattern.MatchString(str) { return nil, types.ErrWrongValue.GenWithStackByArgs(types.DateTimeStr, str) } - tm, err := types.ParseTime(ctx.GetSessionVars().StmtCtx.TypeCtx(), str, mysql.TypeDatetime, types.GetFsp(str), nil) + tm, err := types.ParseTime(ctx.GetSessionVars().StmtCtx.TypeCtx(), str, mysql.TypeDatetime, types.GetFsp(str)) if err != nil { return nil, err } @@ -4548,7 +4548,7 @@ func isDuration(str string) bool { // strDatetimeAddDuration adds duration to datetime string, returns a string value. func strDatetimeAddDuration(sc *stmtctx.StatementContext, d string, arg1 types.Duration) (result string, isNull bool, err error) { - arg0, err := types.ParseTime(sc.TypeCtx(), d, mysql.TypeDatetime, types.MaxFsp, nil) + arg0, err := types.ParseTime(sc.TypeCtx(), d, mysql.TypeDatetime, types.MaxFsp) if err != nil { // Return a warning regardless of the sql_mode, this is compatible with MySQL. sc.AppendWarning(err) @@ -4585,7 +4585,7 @@ func strDurationAddDuration(sc *stmtctx.StatementContext, d string, arg1 types.D // strDatetimeSubDuration subtracts duration from datetime string, returns a string value. func strDatetimeSubDuration(sc *stmtctx.StatementContext, d string, arg1 types.Duration) (result string, isNull bool, err error) { - arg0, err := types.ParseTime(sc.TypeCtx(), d, mysql.TypeDatetime, types.MaxFsp, nil) + arg0, err := types.ParseTime(sc.TypeCtx(), d, mysql.TypeDatetime, types.MaxFsp) if err != nil { // Return a warning regardless of the sql_mode, this is compatible with MySQL. sc.AppendWarning(err) diff --git a/pkg/expression/builtin_time_vec.go b/pkg/expression/builtin_time_vec.go index 457a531e9ab68..9751f27e87916 100644 --- a/pkg/expression/builtin_time_vec.go +++ b/pkg/expression/builtin_time_vec.go @@ -2661,7 +2661,7 @@ func (b *builtinTimestamp1ArgSig) vecEvalTime(ctx sessionctx.Context, input *chu if b.isFloat { tm, err = types.ParseTimeFromFloatString(sc.TypeCtx(), s, mysql.TypeDatetime, types.GetFsp(s)) } else { - tm, err = types.ParseTime(sc.TypeCtx(), s, mysql.TypeDatetime, types.GetFsp(s), nil) + tm, err = types.ParseTime(sc.TypeCtx(), s, mysql.TypeDatetime, types.GetFsp(s)) } if err != nil { if err = handleInvalidTimeError(b.ctx, err); err != nil { @@ -2714,7 +2714,7 @@ func (b *builtinTimestamp2ArgsSig) vecEvalTime(ctx sessionctx.Context, input *ch if b.isFloat { tm, err = types.ParseTimeFromFloatString(sc.TypeCtx(), arg0, mysql.TypeDatetime, types.GetFsp(arg0)) } else { - tm, err = types.ParseTime(sc.TypeCtx(), arg0, mysql.TypeDatetime, types.GetFsp(arg0), nil) + tm, err = types.ParseTime(sc.TypeCtx(), arg0, mysql.TypeDatetime, types.GetFsp(arg0)) } if err != nil { if err = handleInvalidTimeError(b.ctx, err); err != nil { diff --git a/pkg/expression/helper.go b/pkg/expression/helper.go index 0643db7f850e9..d2e7649bd4fa2 100644 --- a/pkg/expression/helper.go +++ b/pkg/expression/helper.go @@ -89,8 +89,11 @@ func getTimeCurrentTimeStamp(ctx sessionctx.Context, tp byte, fsp int) (t types. // GetTimeValue gets the time value with type tp. func GetTimeValue(ctx sessionctx.Context, v interface{}, tp byte, fsp int, explicitTz *time.Location) (d types.Datum, err error) { var value types.Time + tc := ctx.GetSessionVars().StmtCtx.TypeCtx() + if explicitTz != nil { + tc = tc.WithLocation(explicitTz) + } - sc := ctx.GetSessionVars().StmtCtx switch x := v.(type) { case string: lowerX := strings.ToLower(x) @@ -99,10 +102,10 @@ func GetTimeValue(ctx sessionctx.Context, v interface{}, tp byte, fsp int, expli return d, err } } else if lowerX == types.ZeroDatetimeStr { - value, err = types.ParseTimeFromNum(sc.TypeCtx(), 0, tp, fsp) + value, err = types.ParseTimeFromNum(tc, 0, tp, fsp) terror.Log(err) } else { - value, err = types.ParseTime(sc.TypeCtx(), x, tp, fsp, explicitTz) + value, err = types.ParseTime(tc, x, tp, fsp) if err != nil { return d, err } @@ -110,12 +113,12 @@ func GetTimeValue(ctx sessionctx.Context, v interface{}, tp byte, fsp int, expli case *driver.ValueExpr: switch x.Kind() { case types.KindString: - value, err = types.ParseTime(sc.TypeCtx(), x.GetString(), tp, fsp, nil) + value, err = types.ParseTime(tc, x.GetString(), tp, fsp) if err != nil { return d, err } case types.KindInt64: - value, err = types.ParseTimeFromNum(sc.TypeCtx(), x.GetInt64(), tp, fsp) + value, err = types.ParseTimeFromNum(tc, x.GetInt64(), tp, fsp) if err != nil { return d, err } @@ -137,12 +140,12 @@ func GetTimeValue(ctx sessionctx.Context, v interface{}, tp byte, fsp int, expli return d, err } ft := types.NewFieldType(mysql.TypeLonglong) - xval, err := v.ConvertTo(ctx.GetSessionVars().StmtCtx.TypeCtx(), ft) + xval, err := v.ConvertTo(tc, ft) if err != nil { return d, err } - value, err = types.ParseTimeFromNum(sc.TypeCtx(), xval.GetInt64(), tp, fsp) + value, err = types.ParseTimeFromNum(tc, xval.GetInt64(), tp, fsp) if err != nil { return d, err } diff --git a/pkg/server/handler/optimizor/statistics_handler.go b/pkg/server/handler/optimizor/statistics_handler.go index 4af77791cd901..ba83fc805a68f 100644 --- a/pkg/server/handler/optimizor/statistics_handler.go +++ b/pkg/server/handler/optimizor/statistics_handler.go @@ -111,7 +111,7 @@ func (sh StatsHistoryHandler) ServeHTTP(w http.ResponseWriter, req *http.Request } se.GetSessionVars().StmtCtx.SetTimeZone(time.Local) - t, err := types.ParseTime(se.GetSessionVars().StmtCtx.TypeCtx(), params[handler.Snapshot], mysql.TypeTimestamp, 6, nil) + t, err := types.ParseTime(se.GetSessionVars().StmtCtx.TypeCtx(), params[handler.Snapshot], mysql.TypeTimestamp, 6) if err != nil { handler.WriteError(w, err) return diff --git a/pkg/server/internal/column/column_test.go b/pkg/server/internal/column/column_test.go index ba63d52a5b9d8..f4fdceab40962 100644 --- a/pkg/server/internal/column/column_test.go +++ b/pkg/server/internal/column/column_test.go @@ -184,7 +184,7 @@ func TestDumpTextValue(t *testing.T) { require.NoError(t, err) typeCtx := types.NewContext(types.StrictFlags.WithIgnoreZeroInDate(true), losAngelesTz, func(err error) {}) - time, err := types.ParseTime(typeCtx, "2017-01-05 23:59:59.575601", mysql.TypeDatetime, 0, nil) + time, err := types.ParseTime(typeCtx, "2017-01-05 23:59:59.575601", mysql.TypeDatetime, 0) require.NoError(t, err) d.SetMysqlTime(time) columns[0].Type = mysql.TypeDatetime diff --git a/pkg/sessionctx/variable/varsutil.go b/pkg/sessionctx/variable/varsutil.go index 765367a999526..46e13f2e0a8c4 100644 --- a/pkg/sessionctx/variable/varsutil.go +++ b/pkg/sessionctx/variable/varsutil.go @@ -441,7 +441,7 @@ func parseTSFromNumberOrTime(s *SessionVars, sVal string) (uint64, error) { return tso, nil } - t, err := types.ParseTime(s.StmtCtx.TypeCtx(), sVal, mysql.TypeTimestamp, types.MaxFsp, nil) + t, err := types.ParseTime(s.StmtCtx.TypeCtx(), sVal, mysql.TypeTimestamp, types.MaxFsp) if err != nil { return 0, err } @@ -456,7 +456,7 @@ func setTxnReadTS(s *SessionVars, sVal string) error { return nil } - t, err := types.ParseTime(s.StmtCtx.TypeCtx(), sVal, mysql.TypeTimestamp, types.MaxFsp, nil) + t, err := types.ParseTime(s.StmtCtx.TypeCtx(), sVal, mysql.TypeTimestamp, types.MaxFsp) if err != nil { return err } diff --git a/pkg/types/convert.go b/pkg/types/convert.go index 9927ecf879151..2dff482ac5d1f 100644 --- a/pkg/types/convert.go +++ b/pkg/types/convert.go @@ -316,7 +316,7 @@ func StrToUint(ctx Context, str string, isFuncCast bool) (uint64, error) { // StrToDateTime converts str to MySQL DateTime. func StrToDateTime(ctx Context, str string, fsp int) (Time, error) { - return ParseTime(ctx, str, mysql.TypeDatetime, fsp, nil) + return ParseTime(ctx, str, mysql.TypeDatetime, fsp) } // StrToDuration converts str to Duration. It returns Duration in normal case, diff --git a/pkg/types/convert_test.go b/pkg/types/convert_test.go index fed44d5670603..4f78ef6267589 100644 --- a/pkg/types/convert_test.go +++ b/pkg/types/convert_test.go @@ -147,14 +147,14 @@ func TestConvertType(t *testing.T) { require.NoError(t, err) require.Equal(t, "10:11:12.1", vv.(Duration).String()) typeCtx := DefaultStmtNoWarningContext - vd, err := ParseTime(typeCtx, "2010-10-10 10:11:11.12345", mysql.TypeDatetime, 2, nil) + vd, err := ParseTime(typeCtx, "2010-10-10 10:11:11.12345", mysql.TypeDatetime, 2) require.Equal(t, "2010-10-10 10:11:11.12", vd.String()) require.NoError(t, err) v, err = Convert(vd, ft) require.NoError(t, err) require.Equal(t, "10:11:11.1", v.(Duration).String()) - vt, err := ParseTime(typeCtx, "2010-10-10 10:11:11.12345", mysql.TypeTimestamp, 2, nil) + vt, err := ParseTime(typeCtx, "2010-10-10 10:11:11.12345", mysql.TypeTimestamp, 2) require.Equal(t, "2010-10-10 10:11:11.12", vt.String()) require.NoError(t, err) v, err = Convert(vt, ft) @@ -343,7 +343,7 @@ func TestConvertToString(t *testing.T) { testToString(t, Enum{Name: "a", Value: 1}, "a") testToString(t, Set{Name: "a", Value: 1}, "a") - t1, err := ParseTime(DefaultStmtNoWarningContext, "2011-11-10 11:11:11.999999", mysql.TypeTimestamp, 6, nil) + t1, err := ParseTime(DefaultStmtNoWarningContext, "2011-11-10 11:11:11.999999", mysql.TypeTimestamp, 6) require.NoError(t, err) testToString(t, t1, "2011-11-10 11:11:11.999999") diff --git a/pkg/types/datum.go b/pkg/types/datum.go index 50ec3035fead6..ac50494fb01cc 100644 --- a/pkg/types/datum.go +++ b/pkg/types/datum.go @@ -1270,7 +1270,7 @@ func (d *Datum) convertToMysqlTimestamp(ctx Context, target *FieldType) (Datum, } t, err = t.RoundFrac(ctx, fsp) case KindString, KindBytes: - t, err = ParseTime(ctx, d.GetString(), mysql.TypeTimestamp, fsp, nil) + t, err = ParseTime(ctx, d.GetString(), mysql.TypeTimestamp, fsp) case KindInt64: t, err = ParseTimeFromNum(ctx, d.GetInt64(), mysql.TypeTimestamp, fsp) case KindMysqlDecimal: @@ -1283,7 +1283,7 @@ func (d *Datum) convertToMysqlTimestamp(ctx Context, target *FieldType) (Datum, ret.SetMysqlTime(t) return ret, err } - t, err = ParseTime(ctx, s, mysql.TypeTimestamp, fsp, nil) + t, err = ParseTime(ctx, s, mysql.TypeTimestamp, fsp) default: return invalidConv(d, mysql.TypeTimestamp) } @@ -1324,7 +1324,7 @@ func (d *Datum) convertToMysqlTime(ctx Context, target *FieldType) (Datum, error case KindMysqlDecimal: t, err = ParseTimeFromFloatString(ctx, d.GetMysqlDecimal().String(), tp, fsp) case KindString, KindBytes: - t, err = ParseTime(ctx, d.GetString(), tp, fsp, nil) + t, err = ParseTime(ctx, d.GetString(), tp, fsp) case KindInt64: t, err = ParseTimeFromNum(ctx, d.GetInt64(), tp, fsp) case KindUint64: @@ -1343,7 +1343,7 @@ func (d *Datum) convertToMysqlTime(ctx Context, target *FieldType) (Datum, error ret.SetMysqlTime(t) return ret, err } - t, err = ParseTime(ctx, s, tp, fsp, nil) + t, err = ParseTime(ctx, s, tp, fsp) default: return invalidConv(d, tp) } diff --git a/pkg/types/datum_test.go b/pkg/types/datum_test.go index b1f4dc053e0eb..53dc48ef05c69 100644 --- a/pkg/types/datum_test.go +++ b/pkg/types/datum_test.go @@ -92,7 +92,7 @@ func TestToBool(t *testing.T) { testDatumToBool(t, CreateBinaryJSON(true), 1) testDatumToBool(t, CreateBinaryJSON(false), 1) testDatumToBool(t, CreateBinaryJSON(""), 1) - t1, err := ParseTime(DefaultStmtNoWarningContext, "2011-11-10 11:11:11.999999", mysql.TypeTimestamp, 6, nil) + t1, err := ParseTime(DefaultStmtNoWarningContext, "2011-11-10 11:11:11.999999", mysql.TypeTimestamp, 6) require.NoError(t, err) testDatumToBool(t, t1, 1) @@ -133,7 +133,7 @@ func TestToInt64(t *testing.T) { testDatumToInt64(t, Set{Name: "a", Value: 1}, int64(1)) testDatumToInt64(t, CreateBinaryJSON(int64(3)), int64(3)) - t1, err := ParseTime(DefaultStmtNoWarningContext, "2011-11-10 11:11:11.999999", mysql.TypeTimestamp, 0, nil) + t1, err := ParseTime(DefaultStmtNoWarningContext, "2011-11-10 11:11:11.999999", mysql.TypeTimestamp, 0) require.NoError(t, err) testDatumToInt64(t, t1, int64(20111110111112)) @@ -221,7 +221,7 @@ func TestConvertToFloat(t *testing.T) { } func mustParseTime(s string, tp byte, fsp int) Time { - t, err := ParseTime(DefaultStmtNoWarningContext, s, tp, fsp, nil) + t, err := ParseTime(DefaultStmtNoWarningContext, s, tp, fsp) if err != nil { panic("ParseTime fail") } diff --git a/pkg/types/format_test.go b/pkg/types/format_test.go index a63d8f161ee7e..a6caefdbe4911 100644 --- a/pkg/types/format_test.go +++ b/pkg/types/format_test.go @@ -68,7 +68,7 @@ func TestTimeFormatMethod(t *testing.T) { }, } for i, tt := range tblDate { - tm, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, 6, nil) + tm, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, 6) require.NoErrorf(t, err, "Parse time fail: %s", tt.Input) str, err := tm.DateFormat(tt.Format) diff --git a/pkg/types/time.go b/pkg/types/time.go index 19df35a56b996..d03cf63560b33 100644 --- a/pkg/types/time.go +++ b/pkg/types/time.go @@ -460,7 +460,7 @@ func (t Time) Convert(ctx Context, tp uint8) (Time, error) { } t1.SetType(tp) - err := t1.check(ctx, nil) + err := t1.Check(ctx) return t1, errors.Trace(err) } @@ -491,7 +491,7 @@ func (t Time) Compare(o Time) int { // but parses string to Time then compares. func (t Time) CompareString(ctx Context, str string) (int, error) { // use MaxFsp to parse the string - o, err := ParseTime(ctx, str, t.Type(), MaxFsp, nil) + o, err := ParseTime(ctx, str, t.Type(), MaxFsp) if err != nil { return 0, errors.Trace(err) } @@ -670,27 +670,22 @@ func (t *Time) FromPackedUint(packed uint64) error { return nil } -// check whether t matches valid Time format. +// Check function checks whether t matches valid Time format. // If allowZeroInDate is false, it returns ErrZeroDate when month or day is zero. // FIXME: See https://dev.mysql.com/doc/refman/5.7/en/sql-mode.html#sqlmode_no_zero_in_date -func (t Time) check(ctx Context, explicitTz *gotime.Location) error { +func (t Time) Check(ctx Context) error { allowZeroInDate := ctx.Flags().IgnoreZeroInDate() allowInvalidDate := ctx.Flags().IgnoreInvalidDateErr() var err error switch t.Type() { case mysql.TypeTimestamp: - err = checkTimestampType(ctx, t.coreTime, explicitTz) + err = checkTimestampType(t.coreTime, ctx.Location()) case mysql.TypeDatetime, mysql.TypeDate: err = checkDatetimeType(t.coreTime, allowZeroInDate, allowInvalidDate) } return errors.Trace(err) } -// Check if 't' is valid -func (t *Time) Check(ctx Context) error { - return t.check(ctx, nil) -} - // Sub subtracts t1 from t, returns a duration value. // Note that sub should not be done on different time types. func (t *Time) Sub(ctx Context, t1 *Time) Duration { @@ -947,7 +942,7 @@ func splitDateTime(format string) (seps []string, fracStr string, hasTZ bool, tz } // See https://dev.mysql.com/doc/refman/5.7/en/date-and-time-literals.html. -func parseDatetime(ctx Context, str string, fsp int, isFloat bool, explicitTz *gotime.Location) (Time, error) { +func parseDatetime(ctx Context, str string, fsp int, isFloat bool) (Time, error) { var ( year, month, day, hour, minute, second, deltaHour, deltaMinute int fracStr string @@ -1183,12 +1178,7 @@ func parseDatetime(ctx Context, str string, fsp int, isFloat bool, explicitTz *g if overflow { // Convert to Go time and add 1 second, to handle input like 2017-01-05 08:40:59.575601 var t1 gotime.Time - if explicitTz != nil { - t1, err = tmp.GoTime(explicitTz) - } else { - t1, err = tmp.GoTime(ctx.Location()) - } - if err != nil { + if t1, err = tmp.GoTime(ctx.Location()); err != nil { return ZeroDatetime, errors.Trace(err) } tmp = FromGoTime(t1.Add(gotime.Second)) @@ -1220,11 +1210,7 @@ func parseDatetime(ctx Context, str string, fsp int, isFloat bool, explicitTz *g if err != nil { return ZeroDatetime, errors.Trace(err) } - if explicitTz != nil { - t1 = t1.In(explicitTz) - } else { - t1 = t1.In(ctx.Location()) - } + t1 = t1.In(ctx.Location()) tmp = FromGoTime(t1) } @@ -1879,7 +1865,7 @@ func getTime(ctx Context, num, originNum int64, tp byte) (Time, error) { return ZeroDatetime, errors.Trace(ErrWrongValue.GenWithStackByArgs(TimeStr, numStr)) } t := NewTime(ct, tp, DefaultFsp) - err := t.check(ctx, nil) + err := t.Check(ctx) return t, errors.Trace(err) } @@ -1972,8 +1958,8 @@ func parseDateTimeFromNum(ctx Context, num int64) (Time, error) { // The valid timestamp range is from '1970-01-01 00:00:01.000000' to '2038-01-19 03:14:07.999999'. // The valid date range is from '1000-01-01' to '9999-12-31' // explicitTz is used to handle a data race of timeZone, refer to https://github.com/pingcap/tidb/issues/40710. It only works for timestamp now, be careful to use it! -func ParseTime(ctx Context, str string, tp byte, fsp int, explicitTz *gotime.Location) (Time, error) { - return parseTime(ctx, str, tp, fsp, false, explicitTz) +func ParseTime(ctx Context, str string, tp byte, fsp int) (Time, error) { + return parseTime(ctx, str, tp, fsp, false) } // ParseTimeFromFloatString is similar to ParseTime, except that it's used to parse a float converted string. @@ -1982,22 +1968,22 @@ func ParseTimeFromFloatString(ctx Context, str string, tp byte, fsp int) (Time, if len(str) >= 3 && str[:3] == "0.0" { return NewTime(ZeroCoreTime, tp, DefaultFsp), nil } - return parseTime(ctx, str, tp, fsp, true, nil) + return parseTime(ctx, str, tp, fsp, true) } -func parseTime(ctx Context, str string, tp byte, fsp int, isFloat bool, explicitTz *gotime.Location) (Time, error) { +func parseTime(ctx Context, str string, tp byte, fsp int, isFloat bool) (Time, error) { fsp, err := CheckFsp(fsp) if err != nil { return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err) } - t, err := parseDatetime(ctx, str, fsp, isFloat, explicitTz) + t, err := parseDatetime(ctx, str, fsp, isFloat) if err != nil { return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err) } t.SetType(tp) - if err = t.check(ctx, explicitTz); err != nil { + if err = t.Check(ctx); err != nil { return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err) } return t, nil @@ -2005,18 +1991,18 @@ func parseTime(ctx Context, str string, tp byte, fsp int, isFloat bool, explicit // ParseDatetime is a helper function wrapping ParseTime with datetime type and default fsp. func ParseDatetime(ctx Context, str string) (Time, error) { - return ParseTime(ctx, str, mysql.TypeDatetime, GetFsp(str), nil) + return ParseTime(ctx, str, mysql.TypeDatetime, GetFsp(str)) } // ParseTimestamp is a helper function wrapping ParseTime with timestamp type and default fsp. func ParseTimestamp(ctx Context, str string) (Time, error) { - return ParseTime(ctx, str, mysql.TypeTimestamp, GetFsp(str), nil) + return ParseTime(ctx, str, mysql.TypeTimestamp, GetFsp(str)) } // ParseDate is a helper function wrapping ParseTime with date type. func ParseDate(ctx Context, str string) (Time, error) { // date has no fractional seconds precision - return ParseTime(ctx, str, mysql.TypeDate, MinFsp, nil) + return ParseTime(ctx, str, mysql.TypeDate, MinFsp) } // ParseTimeFromYear parse a `YYYY` formed year to corresponded Datetime type. @@ -2060,7 +2046,7 @@ func ParseTimeFromNum(ctx Context, num int64, tp byte, fsp int) (Time, error) { t.SetType(tp) t.SetFsp(fsp) - if err := t.check(ctx, nil); err != nil { + if err := t.Check(ctx); err != nil { return NewTime(ZeroCoreTime, tp, DefaultFsp), errors.Trace(err) } return t, nil @@ -2149,16 +2135,12 @@ func checkMonthDay(year, month, day int, allowInvalidDate bool) error { return nil } -func checkTimestampType(ctx Context, t CoreTime, explicitTz *gotime.Location) error { +func checkTimestampType(t CoreTime, tz *gotime.Location) error { if compareTime(t, ZeroCoreTime) == 0 { return nil } var checkTime CoreTime - tz := ctx.Location() - if explicitTz != nil { - tz = explicitTz - } if tz != BoundTimezone { convertTime := NewTime(t, mysql.TypeTimestamp, DefaultFsp) err := convertTime.ConvertTimeZone(tz, BoundTimezone) @@ -2897,7 +2879,7 @@ func (t *Time) StrToDate(typeCtx Context, date, format string) bool { t.SetCoreTime(tm) t.SetType(mysql.TypeDatetime) - if t.check(typeCtx, nil) != nil { + if t.Check(typeCtx) != nil { return false } if warning { diff --git a/pkg/types/time_test.go b/pkg/types/time_test.go index 0af88d4aaf276..931ed7d2eb55c 100644 --- a/pkg/types/time_test.go +++ b/pkg/types/time_test.go @@ -147,12 +147,12 @@ func TestDateTime(t *testing.T) { } for _, test := range fspTbl { - v, err := types.ParseTime(typeCtx, test.Input, mysql.TypeDatetime, test.Fsp, nil) + v, err := types.ParseTime(typeCtx, test.Input, mysql.TypeDatetime, test.Fsp) require.NoError(t, err) require.Equal(t, test.Expect, v.String()) } - v, _ := types.ParseTime(typeCtx, "121231113045.9999999", mysql.TypeDatetime, 6, nil) + v, _ := types.ParseTime(typeCtx, "121231113045.9999999", mysql.TypeDatetime, 6) require.Equal(t, 46, v.Second()) require.Equal(t, 0, v.Microsecond()) @@ -615,7 +615,7 @@ func TestCodec(t *testing.T) { } for _, test := range tbl { - v, err := types.ParseTime(typeCtx, test, mysql.TypeDatetime, types.MaxFsp, nil) + v, err := types.ParseTime(typeCtx, test, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) packed, _ = v.ToPackedUint() @@ -719,7 +719,7 @@ func TestToNumber(t *testing.T) { } for _, test := range tblDateTime { - v, err := types.ParseTime(typeCtx, test.Input, mysql.TypeDatetime, test.Fsp, nil) + v, err := types.ParseTime(typeCtx, test.Input, mysql.TypeDatetime, test.Fsp) require.NoError(t, err) require.Equal(t, test.Expect, v.ToNumber().String()) } @@ -742,7 +742,7 @@ func TestToNumber(t *testing.T) { } for _, test := range tblDate { - v, err := types.ParseTime(typeCtx, test.Input, mysql.TypeDate, 0, nil) + v, err := types.ParseTime(typeCtx, test.Input, mysql.TypeDate, 0) require.NoError(t, err) require.Equal(t, test.Expect, v.ToNumber().String()) } @@ -860,7 +860,7 @@ func TestRoundFrac(t *testing.T) { } for _, tt := range tbl { - v, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, types.MaxFsp, nil) + v, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) nv, err := v.RoundFrac(typeCtx, tt.Fsp) require.NoError(t, err) @@ -885,7 +885,7 @@ func TestRoundFrac(t *testing.T) { } for _, tt := range tbl { - v, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, types.MaxFsp, nil) + v, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) nv, err := v.RoundFrac(typeCtx, tt.Fsp) require.NoError(t, err) @@ -947,7 +947,7 @@ func TestConvert(t *testing.T) { } for _, tt := range tbl { - v, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, tt.Fsp, nil) + v, err := types.ParseTime(typeCtx, tt.Input, mysql.TypeDatetime, tt.Fsp) require.NoError(t, err) nv, err := v.ConvertToDuration() require.NoError(t, err) @@ -992,7 +992,7 @@ func TestCompare(t *testing.T) { } for _, tt := range tbl { - v1, err := types.ParseTime(typeCtx, tt.Arg1, mysql.TypeDatetime, types.MaxFsp, nil) + v1, err := types.ParseTime(typeCtx, tt.Arg1, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) ret, err := v1.CompareString(types.DefaultStmtNoWarningContext, tt.Arg2) @@ -1000,7 +1000,7 @@ func TestCompare(t *testing.T) { require.Equal(t, tt.Ret, ret) } - v1, err := types.ParseTime(typeCtx, "2011-10-10 11:11:11", mysql.TypeDatetime, types.MaxFsp, nil) + v1, err := types.ParseTime(typeCtx, "2011-10-10 11:11:11", mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) res, err := v1.CompareString(types.DefaultStmtNoWarningContext, "Test should error") require.Error(t, err) @@ -1154,11 +1154,11 @@ func TestTimeAdd(t *testing.T) { typeCtx := types.DefaultStmtNoWarningContext for _, tt := range tbl { - v1, err := types.ParseTime(typeCtx, tt.Arg1, mysql.TypeDatetime, types.MaxFsp, nil) + v1, err := types.ParseTime(typeCtx, tt.Arg1, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) dur, _, err := types.ParseDuration(typeCtx, tt.Arg2, types.MaxFsp) require.NoError(t, err) - result, err := types.ParseTime(typeCtx, tt.Ret, mysql.TypeDatetime, types.MaxFsp, nil) + result, err := types.ParseTime(typeCtx, tt.Ret, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) v2, err := v1.Add(typeCtx, dur) require.NoError(t, err) @@ -1241,7 +1241,7 @@ func TestCheckTimestamp(t *testing.T) { } for _, tt := range tests { - validTimestamp := types.CheckTimestampTypeForTest(types.NewContext(types.StrictFlags, tt.tz, func(err error) {}), tt.input, nil) + validTimestamp := types.CheckTimestampTypeForTest(tt.input, tt.tz) if tt.expectRetError { require.Errorf(t, validTimestamp, "For %s %s", tt.input, tt.tz) } else { @@ -1298,7 +1298,7 @@ func TestCheckTimestamp(t *testing.T) { } for _, tt := range tests { - validTimestamp := types.CheckTimestampTypeForTest(types.NewContext(types.StrictFlags, tt.tz, func(err error) {}), tt.input, nil) + validTimestamp := types.CheckTimestampTypeForTest(tt.input, tt.tz) if tt.expectRetError { require.Errorf(t, validTimestamp, "For %s %s", tt.input, tt.tz) } else { @@ -1970,9 +1970,9 @@ func TestTimeSub(t *testing.T) { typeCtx := types.DefaultStmtNoWarningContext for _, tt := range tbl { - v1, err := types.ParseTime(typeCtx, tt.Arg1, mysql.TypeDatetime, types.MaxFsp, nil) + v1, err := types.ParseTime(typeCtx, tt.Arg1, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) - v2, err := types.ParseTime(typeCtx, tt.Arg2, mysql.TypeDatetime, types.MaxFsp, nil) + v2, err := types.ParseTime(typeCtx, tt.Arg2, mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) dur, _, err := types.ParseDuration(typeCtx, tt.Ret, types.MaxFsp) require.NoError(t, err) @@ -2166,7 +2166,7 @@ func TestParseWithTimezone(t *testing.T) { }, } for ith, ca := range cases { - v, err := types.ParseTime(types.NewContext(types.StrictFlags, ca.sysTZ, func(err error) {}), ca.lit, mysql.TypeTimestamp, ca.fsp, nil) + v, err := types.ParseTime(types.NewContext(types.StrictFlags, ca.sysTZ, func(err error) {}), ca.lit, mysql.TypeTimestamp, ca.fsp) require.NoErrorf(t, err, "tidb time parse misbehaved on %d", ith) if err != nil { continue @@ -2179,7 +2179,7 @@ func TestParseWithTimezone(t *testing.T) { func TestMarshalTime(t *testing.T) { typeCtx := types.DefaultStmtNoWarningContext - v1, err := types.ParseTime(typeCtx, "2017-01-18 01:01:01.123456", mysql.TypeDatetime, types.MaxFsp, nil) + v1, err := types.ParseTime(typeCtx, "2017-01-18 01:01:01.123456", mysql.TypeDatetime, types.MaxFsp) require.NoError(t, err) j, err := json.Marshal(v1) require.NoError(t, err) @@ -2200,7 +2200,7 @@ func BenchmarkFormat(b *testing.B) { func BenchmarkTimeAdd(b *testing.B) { typeCtx := types.DefaultStmtNoWarningContext - arg1, _ := types.ParseTime(typeCtx, "2017-01-18", mysql.TypeDatetime, types.MaxFsp, nil) + arg1, _ := types.ParseTime(typeCtx, "2017-01-18", mysql.TypeDatetime, types.MaxFsp) arg2, _, _ := types.ParseDuration(typeCtx, "12:30:59", types.MaxFsp) for i := 0; i < b.N; i++ { _, err := arg1.Add(typeCtx, arg2) diff --git a/pkg/util/codec/codec_test.go b/pkg/util/codec/codec_test.go index b223938662c23..6fad14dc5088d 100644 --- a/pkg/util/codec/codec_test.go +++ b/pkg/util/codec/codec_test.go @@ -520,7 +520,7 @@ func TestBytes(t *testing.T) { func parseTime(t *testing.T, s string) types.Time { sc := stmtctx.NewStmtCtxWithTimeZone(time.UTC) - m, err := types.ParseTime(sc.TypeCtx(), s, mysql.TypeDatetime, types.DefaultFsp, nil) + m, err := types.ParseTime(sc.TypeCtx(), s, mysql.TypeDatetime, types.DefaultFsp) require.NoError(t, err) return m } diff --git a/pkg/util/dbutil/common.go b/pkg/util/dbutil/common.go index 0ab538e247371..dabae40c8059d 100644 --- a/pkg/util/dbutil/common.go +++ b/pkg/util/dbutil/common.go @@ -551,7 +551,7 @@ func AnalyzeValuesFromBuckets(valueString string, cols []*model.ColumnInfo) ([]s if IsTimeTypeAndNeedDecode(col.GetType()) { // check if values[i] is already a time string sc := stmtctx.NewStmtCtxWithTimeZone(time.UTC) - _, err := types.ParseTime(sc.TypeCtx(), values[i], col.GetType(), types.MinFsp, nil) + _, err := types.ParseTime(sc.TypeCtx(), values[i], col.GetType(), types.MinFsp) if err == nil { continue } diff --git a/pkg/util/rowcodec/rowcodec_test.go b/pkg/util/rowcodec/rowcodec_test.go index e3c6086cdc12d..94f49bf3c3abd 100644 --- a/pkg/util/rowcodec/rowcodec_test.go +++ b/pkg/util/rowcodec/rowcodec_test.go @@ -292,7 +292,7 @@ func TestTypesNewRowCodec(t *testing.T) { return d } getTime := func(value string) types.Time { - d, err := types.ParseTime(types.DefaultStmtNoWarningContext, value, mysql.TypeTimestamp, 6, nil) + d, err := types.ParseTime(types.DefaultStmtNoWarningContext, value, mysql.TypeTimestamp, 6) require.NoError(t, err) return d }