fix stylecheck

fix pingcap#4754, fix pingcap#3839

ddl/ddl.go

@@ -198,7 +198,7 @@ type DDL interface {
 	DropSchema(ctx sessionctx.Context, schema model.CIStr) error
 	CreateTable(ctx sessionctx.Context, stmt *ast.CreateTableStmt, withSelect bool) (int64, error)
 	CreateTableWithLike(ctx sessionctx.Context, ident, referIdent ast.Ident, ifNotExists bool) (int64, error)
-	DropTable(ctx sessionctx.Context, tableIdent ast.Ident, tableId int64) (err error)
+	DropTable(ctx sessionctx.Context, tableIdent ast.Ident, tableID int64) (err error)
 	CreateIndex(ctx sessionctx.Context, tableIdent ast.Ident, unique bool, indexName model.CIStr,
 		columnNames []*ast.IndexColName, indexOption *ast.IndexOption) error
 	DropIndex(ctx sessionctx.Context, tableIdent ast.Ident, indexName model.CIStr) error

ddl/ddl_api.go

@@ -1831,24 +1831,24 @@ func (d *ddl) RenameIndex(ctx sessionctx.Context, ident ast.Ident, spec *ast.Alt
 }
 
 // DropTable will proceed even if some table in the list does not exists.
-func (d *ddl) DropTable(ctx sessionctx.Context, ti ast.Ident, tableId int64) (err error) {
+func (d *ddl) DropTable(ctx sessionctx.Context, ti ast.Ident, tableID int64) (err error) {
 	is := d.GetInformationSchema(ctx)
 	schema, ok := is.SchemaByName(ti.Schema)
 	if !ok {
 		return infoschema.ErrDatabaseNotExists.GenWithStackByArgs(ti.Schema)
 	}
 
-	if tableId == 0 {
-		tb, err := is.TableByName(ti.Schema, ti.Name)
-		if err != nil {
+	if tableID == 0 {
+		tb, e := is.TableByName(ti.Schema, ti.Name)
+		if e != nil {
 			return errors.Trace(infoschema.ErrTableNotExists.GenWithStackByArgs(ti.Schema, ti.Name))
 		}
-		tableId = tb.Meta().ID
+		tableID = tb.Meta().ID
 	}
 
 	job := &model.Job{
 		SchemaID:   schema.ID,
-		TableID:    tableId,
+		TableID:    tableID,
 		Type:       model.ActionDropTable,
 		BinlogInfo: &model.HistoryInfo{},
 	}

ddl/table.go

@@ -74,7 +74,7 @@ func onCreateTable(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, _ error)
 			// TODO: Add restrictions to this operation.
 			go splitTableRegion(d.store, tbInfo.ID)
 		}
-		ver, err := updateVersionAndTableInfo(t, job, tbInfo, originalState != tbInfo.State)
+		ver, err = updateVersionAndTableInfo(t, job, tbInfo, originalState != tbInfo.State)
 		if err != nil {
 			job.State = model.JobStateCancelled
 			return ver, err
@@ -89,9 +89,9 @@ func onCreateTable(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, _ error)
 	}
 }
 
-func onRevealTable(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, _ error) {
+func onRevealTable(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, err error) {
 	tbInfo := &model.TableInfo{}
-	if err := job.DecodeArgs(tbInfo); err != nil {
+	if err = job.DecodeArgs(tbInfo); err != nil {
 		// Invalid arguments, cancel this job.
 		job.State = model.JobStateCancelled
 		return ver, errors.Trace(err)
@@ -104,7 +104,7 @@ func onRevealTable(d *ddlCtx, t *meta.Meta, job *model.Job) (ver int64, _ error)
 		tbInfo.State = model.StatePublic
 		tbInfo.UpdateTS = t.StartTS
 		// Finish this job.
-		ver, err := updateVersionAndTableInfo(t, job, tbInfo, originalState != tbInfo.State)
+		ver, err = updateVersionAndTableInfo(t, job, tbInfo, originalState != tbInfo.State)
 		if err != nil {
 			job.State = model.JobStateCancelled
 			return ver, err

executor/ddl.go

@@ -81,7 +81,8 @@ func (e *DDLExec) Next(ctx context.Context, chk *chunk.Chunk) (err error) {
 	case *ast.CreateDatabaseStmt:
 		err = e.executeCreateDatabase(x)
 	case *ast.CreateTableStmt:
-		tableID, err := e.executeCreateTable(x)
+		var tableID int64
+		tableID, err = e.executeCreateTable(x)
 		if err != nil {
 			return errors.Trace(e.toErr(err))
 		}

executor/show.go

@@ -351,19 +351,19 @@ func (e *ShowExec) fetchShowIndex() error {
 				subPart = col.Length
 			}
 			e.appendRow([]interface{}{
-				tb.Meta().Name.O,  // Table
-				nonUniq,           // Non_unique
-				idx.Meta().Name.O, // Key_name
-				i + 1,             // Seq_in_index
-				col.Name.O,        // Column_name
-				"A",               // Collation
-				0,                 // Cardinality
-				subPart,           // Sub_part
-				nil,               // Packed
-				"YES",             // Null
+				tb.Meta().Name.O,       // Table
+				nonUniq,                // Non_unique
+				idx.Meta().Name.O,      // Key_name
+				i + 1,                  // Seq_in_index
+				col.Name.O,             // Column_name
+				"A",                    // Collation
+				0,                      // Cardinality
+				subPart,                // Sub_part
+				nil,                    // Packed
+				"YES",                  // Null
 				idx.Meta().Tp.String(), // Index_type
-				"",                 // Comment
-				idx.Meta().Comment, // Index_comment
+				"",                     // Comment
+				idx.Meta().Comment,     // Index_comment
 			})
 		}
 	}

types/field_type.go

@@ -73,15 +73,18 @@ func (ft *FieldType) Equal(other *FieldType) bool {
 	return true
 }
 
+// Clone makes a deep copy of FieldType
 func (ft *FieldType) Clone() *FieldType {
+	elems := make([]string, len(ft.Elems))
+	copy(elems, ft.Elems)
 	return &FieldType{
 		Tp:      ft.Tp,
 		Flag:    ft.Flag,
 		Flen:    ft.Flen,
 		Decimal: ft.Decimal,
 		Charset: ft.Charset,
 		Collate: ft.Collate,
-		Elems:   ft.Elems,
+		Elems:   elems,
 	}
 }
 

types/field_type_test.go

@@ -392,3 +392,27 @@ func (s *testFieldTypeSuite) TestAggregateEvalType(c *C) {
 		}
 	}
 }
+
+func (s *testFieldTypeSuite) TestClone(c *C) {
+	defer testleak.AfterTest(c)()
+
+	ft := NewFieldType(mysql.TypeDecimal)
+	c.Assert(ft.Equal(ft.Clone()), IsTrue)
+
+	ft = NewFieldType(mysql.TypeLong)
+	ft.Flen = 5
+	ft.Flag = mysql.UnsignedFlag | mysql.ZerofillFlag
+	c.Assert(ft.Equal(ft.Clone()), IsTrue)
+
+	ft = NewFieldType(mysql.TypeFloat)
+	ft.Flen = 7
+	ft.Decimal = 3
+	ft.Charset = charset.CharsetASCII
+	ft.Collate = charset.CharsetBin
+	ft.Elems = []string{"a", "b", "c"}
+	c.Assert(ft.Equal(ft.Clone()), IsTrue)
+
+	ftc := ft.Clone()
+	ftc.Elems = append(ftc.Elems, "d")
+	c.Assert(ft.Equal(ftc), IsFalse)
+}