From cdfe76c932afd7d87ce21148fd27958280805e45 Mon Sep 17 00:00:00 2001 From: winkyao Date: Mon, 10 Dec 2018 12:58:18 +0800 Subject: [PATCH] ddl: support altering the other charset to utf8 or utf8mb4 (#8037) --- ddl/column_test.go | 2 +- ddl/db_change_test.go | 2 +- ddl/db_integration_test.go | 50 +++++++++++++ ddl/db_test.go | 93 ++++++++++++++++++++++++ ddl/ddl.go | 26 ++++--- ddl/ddl_api.go | 141 ++++++++++++++++++++++++++++++++++--- ddl/ddl_worker.go | 2 + ddl/table.go | 22 ++++++ go.mod | 2 + go.sum | 4 +- 10 files changed, 321 insertions(+), 23 deletions(-) diff --git a/ddl/column_test.go b/ddl/column_test.go index 2c1f96d2e18ba..6a66cbfbf94de 100644 --- a/ddl/column_test.go +++ b/ddl/column_test.go @@ -931,7 +931,7 @@ func (s *testColumnSuite) TestModifyColumn(c *C) { {"int", "int unsigned", errUnsupportedModifyColumn.GenWithStackByArgs("length 10 is less than origin 11")}, {"varchar(10)", "text", nil}, {"varbinary(10)", "blob", nil}, - {"text", "blob", errUnsupportedModifyColumn.GenWithStackByArgs("charset binary not match origin utf8mb4")}, + {"text", "blob", errUnsupportedModifyCharset.GenWithStackByArgs("charset from utf8mb4 to binary")}, {"varchar(10)", "varchar(8)", errUnsupportedModifyColumn.GenWithStackByArgs("length 8 is less than origin 10")}, {"varchar(10)", "varchar(11)", nil}, {"varchar(10) character set utf8 collate utf8_bin", "varchar(10) character set utf8", nil}, diff --git a/ddl/db_change_test.go b/ddl/db_change_test.go index 3a90461aa6a0a..357f2a71e82b5 100644 --- a/ddl/db_change_test.go +++ b/ddl/db_change_test.go @@ -376,7 +376,7 @@ func (s *testStateChangeSuite) TestAppendEnum(c *C) { c.Assert(err.Error(), Equals, "[ddl:203]unsupported modify column the number of enum column's elements is less than the original: 2") failAlterTableSQL2 := "alter table t change c2 c2 int default 0" _, err = s.se.Execute(context.Background(), failAlterTableSQL2) - c.Assert(err.Error(), Equals, "[ddl:203]unsupported modify column charset binary not match origin utf8mb4") + c.Assert(err.Error(), Equals, "[ddl:210]unsupported modify charset from utf8mb4 to binary") alterTableSQL := "alter table t change c2 c2 enum('N','Y','A') DEFAULT 'A'" _, err = s.se.Execute(context.Background(), alterTableSQL) c.Assert(err, IsNil) diff --git a/ddl/db_integration_test.go b/ddl/db_integration_test.go index 185b3c774067e..b6a0da7018612 100644 --- a/ddl/db_integration_test.go +++ b/ddl/db_integration_test.go @@ -170,6 +170,56 @@ func (s *testIntegrationSuite) TestNullGeneratedColumn(c *C) { tk.MustExec("drop table t") } +func (s *testIntegrationSuite) TestChangingCharsetToUtf8(c *C) { + tk := testkit.NewTestKit(c, s.store) + + tk.MustExec("USE test") + tk.MustExec("create table t(a char(10) charset latin1)") + tk.MustExec("alter table t modify column a char(10) charset latin1") + tk.MustExec("alter table t modify column a char(10) charset utf8") + tk.MustExec("alter table t modify column a char(10) charset utf8mb4") + rs, err := tk.Exec("alter table t modify column a char(10) charset utf8mb4 collate utf8bin") + if rs != nil { + rs.Close() + } + c.Assert(err, NotNil) + tk.MustExec("alter table t modify column a char(10) charset utf8mb4 collate utf8mb4_bin") + rs, err = tk.Exec("alter table t modify column a char(10) charset utf8 collate utf8_bin") + if rs != nil { + rs.Close() + } + + c.Assert(err, NotNil) + tk.MustExec("alter table t modify column a char(10) charset utf8mb4 collate utf8mb4_general_ci") +} + +func (s *testIntegrationSuite) TestChangingTableCharset(c *C) { + tk := testkit.NewTestKit(c, s.store) + + tk.MustExec("USE test") + tk.MustExec("create table t(a char(10)) charset latin1 collate latin1_bin") + rs, err := tk.Exec("alter table t charset gbk") + if rs != nil { + rs.Close() + } + c.Assert(err.Error(), Equals, "Unknown charset gbk") + tk.MustExec("alter table t charset utf8") + tk.MustExec("alter table t charset utf8 collate utf8_bin") + rs, err = tk.Exec("alter table t charset utf8 collate latin1_bin") + if rs != nil { + rs.Close() + } + c.Assert(err, NotNil) + tk.MustExec("alter table t charset utf8mb4") + tk.MustExec("alter table t charset utf8mb4 collate utf8mb4_bin") + + rs, err = tk.Exec("alter table t charset utf8 collate utf8_bin") + if rs != nil { + rs.Close() + } + c.Assert(err, NotNil) +} + func (s *testIntegrationSuite) TestCaseInsensitiveCharsetAndCollate(c *C) { tk := testkit.NewTestKit(c, s.store) diff --git a/ddl/db_test.go b/ddl/db_test.go index de7283b507e42..78b6de529a979 100644 --- a/ddl/db_test.go +++ b/ddl/db_test.go @@ -26,6 +26,7 @@ import ( . "github.com/pingcap/check" "github.com/pingcap/errors" "github.com/pingcap/parser/ast" + "github.com/pingcap/parser/charset" "github.com/pingcap/parser/model" "github.com/pingcap/parser/mysql" tmysql "github.com/pingcap/parser/mysql" @@ -3589,6 +3590,98 @@ func (s *testDBSuite) TestPartitionAddIndex(c *C) { tk.MustExec("drop table partition_add_idx") } +func (s *testDBSuite) TestAlterTableCharset(c *C) { + tk := testkit.NewTestKit(c, s.store) + tk.MustExec("create database test_charset") + defer tk.MustExec("drop database test_charset") + tk.MustExec("use test_charset") + tk.MustExec("drop table if exists t") + tk.MustExec("create table t(a int) charset latin1") + ctx := tk.Se.(sessionctx.Context) + is := domain.GetDomain(ctx).InfoSchema() + t, err := is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(err, IsNil) + c.Assert(t.Meta().Charset, Equals, "latin1") + defCollate, err := charset.GetDefaultCollation("latin1") + c.Assert(err, IsNil) + c.Assert(t.Meta().Collate, Equals, defCollate) + + tk.MustExec("alter table t charset utf8") + is = domain.GetDomain(ctx).InfoSchema() + t, err = is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(t.Meta().Charset, Equals, "utf8") + defCollate, err = charset.GetDefaultCollation("utf8") + c.Assert(err, IsNil) + c.Assert(t.Meta().Collate, Equals, defCollate) + + tk.MustExec("alter table t charset utf8mb4 collate utf8mb4_general_ci") + is = domain.GetDomain(ctx).InfoSchema() + t, err = is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(t.Meta().Charset, Equals, "utf8mb4") + c.Assert(t.Meta().Collate, Equals, "utf8mb4_general_ci") + + rs, err := tk.Exec("alter table t charset utf8") + if rs != nil { + rs.Close() + } + + c.Assert(err.Error(), Equals, "[ddl:210]unsupported modify charset from utf8mb4 to utf8") +} + +func (s *testDBSuite) TestAlterColumnCharset(c *C) { + tk := testkit.NewTestKit(c, s.store) + tk.MustExec("create database test_charset") + defer tk.MustExec("drop database test_charset") + tk.MustExec("use test_charset") + tk.MustExec("drop table if exists t") + tk.MustExec("create table t(a char(10) charset latin1)") + ctx := tk.Se.(sessionctx.Context) + is := domain.GetDomain(ctx).InfoSchema() + t, err := is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(err, IsNil) + col := model.FindColumnInfo(t.Meta().Columns, "a") + c.Assert(col, NotNil) + c.Assert(col.Charset, Equals, "latin1") + defCollate, err := charset.GetDefaultCollation("latin1") + c.Assert(err, IsNil) + c.Assert(col.Collate, Equals, defCollate) + + tk.MustExec("alter table t modify column a char(10) charset utf8") + is = domain.GetDomain(ctx).InfoSchema() + t, err = is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(err, IsNil) + col = model.FindColumnInfo(t.Meta().Columns, "a") + c.Assert(col, NotNil) + c.Assert(col.Charset, Equals, "utf8") + defCollate, err = charset.GetDefaultCollation("utf8") + c.Assert(err, IsNil) + c.Assert(col.Collate, Equals, defCollate) + + tk.MustExec("alter table t modify column a char(10) charset utf8 collate utf8_general_ci") + is = domain.GetDomain(ctx).InfoSchema() + t, err = is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(err, IsNil) + col = model.FindColumnInfo(t.Meta().Columns, "a") + c.Assert(col, NotNil) + c.Assert(col.Charset, Equals, "utf8") + c.Assert(col.Collate, Equals, "utf8_general_ci") + + tk.MustExec("alter table t modify column a char(10) charset utf8mb4 collate utf8mb4_general_ci") + is = domain.GetDomain(ctx).InfoSchema() + t, err = is.TableByName(model.NewCIStr("test_charset"), model.NewCIStr("t")) + c.Assert(err, IsNil) + col = model.FindColumnInfo(t.Meta().Columns, "a") + c.Assert(col, NotNil) + c.Assert(col.Charset, Equals, "utf8mb4") + c.Assert(col.Collate, Equals, "utf8mb4_general_ci") + + rs, err := tk.Exec("alter table t modify column a char(10) charset utf8") + if rs != nil { + rs.Close() + } + c.Assert(err.Error(), Equals, "[ddl:210]unsupported modify charset from utf8mb4 to utf8") +} + func (s *testDBSuite) TestDropSchemaWithPartitionTable(c *C) { s.tk = testkit.NewTestKit(c, s.store) s.tk.MustExec("drop database if exists test_db_with_partition") diff --git a/ddl/ddl.go b/ddl/ddl.go index 287f818d635c8..b0aa70275f733 100644 --- a/ddl/ddl.go +++ b/ddl/ddl.go @@ -84,10 +84,11 @@ var ( errInvalidStoreVer = terror.ClassDDL.New(codeInvalidStoreVer, "invalid storage current version") // We don't support dropping column with index covered now. - errCantDropColWithIndex = terror.ClassDDL.New(codeCantDropColWithIndex, "can't drop column with index") - errUnsupportedAddColumn = terror.ClassDDL.New(codeUnsupportedAddColumn, "unsupported add column") - errUnsupportedModifyColumn = terror.ClassDDL.New(codeUnsupportedModifyColumn, "unsupported modify column %s") - errUnsupportedPKHandle = terror.ClassDDL.New(codeUnsupportedDropPKHandle, + errCantDropColWithIndex = terror.ClassDDL.New(codeCantDropColWithIndex, "can't drop column with index") + errUnsupportedAddColumn = terror.ClassDDL.New(codeUnsupportedAddColumn, "unsupported add column") + errUnsupportedModifyColumn = terror.ClassDDL.New(codeUnsupportedModifyColumn, "unsupported modify column %s") + errUnsupportedModifyCharset = terror.ClassDDL.New(codeUnsupportedModifyCharset, "unsupported modify %s") + errUnsupportedPKHandle = terror.ClassDDL.New(codeUnsupportedDropPKHandle, "unsupported drop integer primary key") errUnsupportedCharset = terror.ClassDDL.New(codeUnsupportedCharset, "unsupported charset %s collate %s") @@ -564,13 +565,16 @@ const ( codeInvalidIndexState = 103 codeInvalidForeignKeyState = 104 - codeCantDropColWithIndex = 201 - codeUnsupportedAddColumn = 202 - codeUnsupportedModifyColumn = 203 - codeUnsupportedDropPKHandle = 204 - codeUnsupportedCharset = 205 - codeUnsupportedModifyPrimaryKey = 206 - codeUnsupportedShardRowIDBits = 207 + codeCantDropColWithIndex = 201 + codeUnsupportedAddColumn = 202 + codeUnsupportedModifyColumn = 203 + codeUnsupportedDropPKHandle = 204 + codeUnsupportedCharset = 205 + codeUnsupportedModifyPrimaryKey = 206 + codeUnsupportedShardRowIDBits = 207 + codeUnsupportedAddPartition = 208 + codeUnsupportedCoalescePartition = 209 + codeUnsupportedModifyCharset = 210 codeFileNotFound = 1017 codeErrorOnRename = 1025 diff --git a/ddl/ddl_api.go b/ddl/ddl_api.go index 576a38e428842..a75a98e67f716 100644 --- a/ddl/ddl_api.go +++ b/ddl/ddl_api.go @@ -998,6 +998,17 @@ func (d *ddl) handleAutoIncID(tbInfo *model.TableInfo, schemaID int64) error { return nil } +func setDefaultTableCharsetAndCollation(tbInfo *model.TableInfo) (err error) { + if len(tbInfo.Charset) == 0 { + tbInfo.Charset = mysql.DefaultCharset + } + + if len(tbInfo.Collate) == 0 { + tbInfo.Collate, err = charset.GetDefaultCollation(tbInfo.Charset) + } + return +} + // handleTableOptions updates tableInfo according to table options. func handleTableOptions(options []*ast.TableOption, tbInfo *model.TableInfo) error { for _, op := range options { @@ -1022,6 +1033,8 @@ func handleTableOptions(options []*ast.TableOption, tbInfo *model.TableInfo) err } } } + + setDefaultTableCharsetAndCollation(tbInfo) return nil } @@ -1041,6 +1054,34 @@ func isIgnorableSpec(tp ast.AlterTableType) bool { return tp == ast.AlterTableLock || tp == ast.AlterTableAlgorithm } +// getCharsetAndCollateInTableOption will iterate the charset and collate in the options, +// and returns the last charset and collate in options. If there is no charset in the options, +// the returns charset will be "", the same as collate. +func getCharsetAndCollateInTableOption(startIdx int, options []*ast.TableOption) (charset, collate string) { + charsets := make([]string, len(options)) + collates := make([]string, len(options)) + for i := startIdx; i < len(options); i++ { + opt := options[i] + // we set the charset to the last option. example: alter table t charset latin1 charset utf8 collate utf8_bin; + // the charset will be utf8, collate will be utf8_bin + switch opt.Tp { + case ast.TableOptionCharset: + charsets = append(charsets, opt.StrValue) + case ast.TableOptionCollate: + collates = append(collates, opt.StrValue) + } + } + + if len(charsets) != 0 { + charset = charsets[len(charsets)-1] + } + + if len(collates) != 0 { + collate = collates[len(collates)-1] + } + return +} + func (d *ddl) AlterTable(ctx sessionctx.Context, ident ast.Ident, specs []*ast.AlterTableSpec) (err error) { // Only handle valid specs. validSpecs := make([]*ast.AlterTableSpec, 0, len(specs)) @@ -1058,6 +1099,7 @@ func (d *ddl) AlterTable(ctx sessionctx.Context, ident ast.Ident, specs []*ast.A } for _, spec := range validSpecs { + var handledCharsetOrCollate bool switch spec.Tp { case ast.AlterTableAddColumns: if len(spec.NewColumns) != 1 { @@ -1103,7 +1145,7 @@ func (d *ddl) AlterTable(ctx sessionctx.Context, ident ast.Ident, specs []*ast.A case ast.AlterTableRenameIndex: err = d.RenameIndex(ctx, ident, spec) case ast.AlterTableOption: - for _, opt := range spec.Options { + for i, opt := range spec.Options { switch opt.Tp { case ast.TableOptionShardRowID: if opt.UintValue > shardRowIDBitsMax { @@ -1115,7 +1157,17 @@ func (d *ddl) AlterTable(ctx sessionctx.Context, ident ast.Ident, specs []*ast.A case ast.TableOptionComment: spec.Comment = opt.StrValue err = d.AlterTableComment(ctx, ident, spec) + case ast.TableOptionCharset, ast.TableOptionCollate: + // getCharsetAndCollateInTableOption will get the last charset and collate in the options, + // so it should be handled only once. + if handledCharsetOrCollate { + continue + } + toCharset, toCollate := getCharsetAndCollateInTableOption(i, spec.Options) + err = d.AlterTableCharsetAndCollate(ctx, ident, toCharset, toCollate) + handledCharsetOrCollate = true } + if err != nil { return errors.Trace(err) } @@ -1419,6 +1471,29 @@ func (d *ddl) DropColumn(ctx sessionctx.Context, ti ast.Ident, colName model.CIS return errors.Trace(err) } +// modifiableCharsetAndCollation returns error when the charset or collation is not modifiable. +func modifiableCharsetAndCollation(toCharset, toCollate, origCharset, origCollate string) error { + if !charset.ValidCharsetAndCollation(toCharset, toCollate) { + return ErrUnknownCharacterSet.GenWithStackByArgs(toCharset, toCollate) + } + + if toCharset == charset.CharsetUTF8MB4 || (toCharset == charset.CharsetUTF8 && origCharset != charset.CharsetUTF8MB4) { + // TiDB treats all the data as utf8mb4, so we support changing the charset to utf8mb4. + // And not allow to change utf8mb4 to utf8. + return nil + } + + if toCharset != origCharset { + msg := fmt.Sprintf("charset from %s to %s", origCharset, toCharset) + return errUnsupportedModifyCharset.GenWithStackByArgs(msg) + } + if toCollate != origCollate { + msg := fmt.Sprintf("collate from %s to %s", origCollate, toCollate) + return errUnsupportedModifyCharset.GenWithStackByArgs(msg) + } + return nil +} + // modifiable checks if the 'origin' type can be modified to 'to' type with out the need to // change or check existing data in the table. // It returns true if the two types has the same Charset and Collation, the same sign, both are @@ -1432,14 +1507,10 @@ func modifiable(origin *types.FieldType, to *types.FieldType) error { msg := fmt.Sprintf("decimal %d is less than origin %d", to.Decimal, origin.Decimal) return errUnsupportedModifyColumn.GenWithStackByArgs(msg) } - if to.Charset != origin.Charset { - msg := fmt.Sprintf("charset %s not match origin %s", to.Charset, origin.Charset) - return errUnsupportedModifyColumn.GenWithStackByArgs(msg) - } - if to.Collate != origin.Collate { - msg := fmt.Sprintf("collate %s not match origin %s", to.Collate, origin.Collate) - return errUnsupportedModifyColumn.GenWithStackByArgs(msg) + if err := modifiableCharsetAndCollation(to.Charset, to.Collate, origin.Charset, origin.Collate); err != nil { + return errors.Trace(err) } + toUnsigned := mysql.HasUnsignedFlag(to.Flag) originUnsigned := mysql.HasUnsignedFlag(origin.Flag) if originUnsigned != toUnsigned { @@ -1797,6 +1868,60 @@ func (d *ddl) AlterTableComment(ctx sessionctx.Context, ident ast.Ident, spec *a return errors.Trace(err) } +// AlterTableCharset changes the table charset and collate. +func (d *ddl) AlterTableCharsetAndCollate(ctx sessionctx.Context, ident ast.Ident, toCharset, toCollate string) error { + // use the last one. + if toCharset == "" && toCollate == "" { + return ErrUnknownCharacterSet.GenWithStackByArgs(toCharset) + } + + is := d.infoHandle.Get() + schema, ok := is.SchemaByName(ident.Schema) + if !ok { + return infoschema.ErrDatabaseNotExists.GenWithStackByArgs(ident.Schema) + } + + tb, err := is.TableByName(ident.Schema, ident.Name) + if err != nil { + return errors.Trace(infoschema.ErrTableNotExists.GenWithStackByArgs(ident.Schema, ident.Name)) + } + + origCharset := tb.Meta().Charset + origCollate := tb.Meta().Collate + if toCharset == "" { + // charset does not change. + toCharset = origCharset + } + + if toCollate == "" { + // get the default collation of the charset. + toCollate, err = charset.GetDefaultCollation(toCharset) + if err != nil { + return errors.Trace(err) + } + } + + if origCharset == toCharset && origCollate == toCollate { + // nothing to do. + return nil + } + + if err = modifiableCharsetAndCollation(toCharset, toCollate, origCharset, origCollate); err != nil { + return errors.Trace(err) + } + + job := &model.Job{ + SchemaID: schema.ID, + TableID: tb.Meta().ID, + Type: model.ActionModifyTableCharsetAndCollate, + BinlogInfo: &model.HistoryInfo{}, + Args: []interface{}{toCharset, toCollate}, + } + err = d.doDDLJob(ctx, job) + err = d.callHookOnChanged(err) + return errors.Trace(err) +} + // RenameIndex renames an index. // In TiDB, indexes are case-insensitive (so index 'a' and 'A" are considered the same index), // but index names are case-sensitive (we can rename index 'a' to 'A') diff --git a/ddl/ddl_worker.go b/ddl/ddl_worker.go index 97ca37f66ed5f..27cf87b4a49f1 100644 --- a/ddl/ddl_worker.go +++ b/ddl/ddl_worker.go @@ -502,6 +502,8 @@ func (w *worker) runDDLJob(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, ver, err = onModifyTableComment(t, job) case model.ActionAddTablePartition: ver, err = onAddTablePartition(t, job) + case model.ActionModifyTableCharsetAndCollate: + ver, err = onModifyTableCharsetAndCollate(t, job) default: // Invalid job, cancel it. job.State = model.JobStateCancelled diff --git a/ddl/table.go b/ddl/table.go index 9b994cc6b323f..d444d04bb37b2 100644 --- a/ddl/table.go +++ b/ddl/table.go @@ -388,6 +388,28 @@ func onModifyTableComment(t *meta.Meta, job *model.Job) (ver int64, _ error) { return ver, nil } +func onModifyTableCharsetAndCollate(t *meta.Meta, job *model.Job) (ver int64, _ error) { + var toCharset, toCollate string + if err := job.DecodeArgs(&toCharset, &toCollate); err != nil { + job.State = model.JobStateCancelled + return ver, errors.Trace(err) + } + + tblInfo, err := getTableInfo(t, job, job.SchemaID) + if err != nil { + return ver, errors.Trace(err) + } + + tblInfo.Charset = toCharset + tblInfo.Collate = toCollate + ver, err = updateVersionAndTableInfo(t, job, tblInfo, true) + if err != nil { + return ver, errors.Trace(err) + } + job.FinishTableJob(model.JobStateDone, model.StatePublic, ver, tblInfo) + return ver, nil +} + func checkTableNotExists(t *meta.Meta, job *model.Job, schemaID int64, tableName string) error { // Check this table's database. tables, err := t.ListTables(schemaID) diff --git a/go.mod b/go.mod index 91e70829f3fc8..f20b014e662ae 100644 --- a/go.mod +++ b/go.mod @@ -80,3 +80,5 @@ require ( gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 // indirect gopkg.in/yaml.v2 v2.2.1 // indirect ) + +replace github.com/pingcap/parser => github.com/crazycs520/parser v0.0.0-20190105032941-f24e221ed7dd diff --git a/go.sum b/go.sum index 24a743425b08f..c2f8f19cf6bd1 100644 --- a/go.sum +++ b/go.sum @@ -20,6 +20,8 @@ github.com/coreos/go-systemd v0.0.0-20180202092358-40e2722dffea h1:IHPWgevPcOUjT github.com/coreos/go-systemd v0.0.0-20180202092358-40e2722dffea/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf h1:CAKfRE2YtTUIjjh1bkBtyYFaUT/WmOqsJjgtihT0vMI= github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= +github.com/crazycs520/parser v0.0.0-20190105032941-f24e221ed7dd h1:MAmltXPtLjVBIRK8SmM9NL+zX1LlbhtJxB6jxqPdyG4= +github.com/crazycs520/parser v0.0.0-20190105032941-f24e221ed7dd/go.mod h1:xLjI+gnWYexq011WPMEvCNS8rFM9qe1vdojIEzSKPuc= github.com/cznic/mathutil v0.0.0-20160613104831-78ad7f262603 h1:hhR9hTi0ligs11JjfGDBP332clNOJRdW0Ci5oHtEC+0= github.com/cznic/mathutil v0.0.0-20160613104831-78ad7f262603/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM= github.com/cznic/sortutil v0.0.0-20150617083342-4c7342852e65 h1:hxuZop6tSoOi0sxFzoGGYdRqNrPubyaIf9KoBG9tPiE= @@ -92,8 +94,6 @@ github.com/pingcap/goleveldb v0.0.0-20171020084629-8d44bfdf1030 h1:XJLuW0lsP7vAt github.com/pingcap/goleveldb v0.0.0-20171020084629-8d44bfdf1030/go.mod h1:O17XtbryoCJhkKGbT62+L2OlrniwqiGLSqrmdHCMzZw= github.com/pingcap/kvproto v0.0.0-20181109035735-8e3f33ac4929 h1:NAq95+VGsS2G7SjzZ5LP9iUlCMNAs13QUzbNY3G90v8= github.com/pingcap/kvproto v0.0.0-20181109035735-8e3f33ac4929/go.mod h1:0gwbe1F2iBIjuQ9AH0DbQhL+Dpr5GofU8fgYyXk+ykk= -github.com/pingcap/parser v0.0.0-20181225054907-cae9754c056b h1:BSTVI3Vm99xPNBgvno34KiQRzK/NhcainoBNaxV+a8E= -github.com/pingcap/parser v0.0.0-20181225054907-cae9754c056b/go.mod h1:1FNvfp9+J0wvc4kl8eGNh7Rqrxveg15jJoWo/a0uHwA= github.com/pingcap/pd v2.1.0-rc.4+incompatible h1:/buwGk04aHO5odk/+O8ZOXGs4qkUjYTJ2UpCJXna8NE= github.com/pingcap/pd v2.1.0-rc.4+incompatible/go.mod h1:nD3+EoYes4+aNNODO99ES59V83MZSI+dFbhyr667a0E= github.com/pingcap/tidb-tools v2.1.1-0.20181218072513-b2235d442b06+incompatible h1:Bsd+NHosPVowEGB3BCx+2d8wUQGDTXSSC5ljeNS6cXo=