entc/gen: avoid using Go keywords as variables on scan

Summary: Pull Request resolved: https://github.com/facebookincubator/ent/pull/161

Reviewed By: alexsn

Differential Revision: D18483166

fbshipit-source-id: 7273d284232c1bf515cc84326904b580fb70a0e3

entc/integration/config/ent/user.go

@@ -22,16 +22,16 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID int
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
+		&scanu.ID,
 	); err != nil {
 		return err
 	}
-	u.ID = vu.ID
+	u.ID = scanu.ID
 	return nil
 }
 
@@ -68,11 +68,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }

entc/integration/ent/card.go

@@ -36,7 +36,7 @@ type Card struct {
 
 // FromRows scans the sql response data into Card.
 func (c *Card) FromRows(rows *sql.Rows) error {
-	var vc struct {
+	var scanc struct {
 		ID         int
 		CreateTime sql.NullTime
 		UpdateTime sql.NullTime
@@ -45,19 +45,19 @@ func (c *Card) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `card.Columns`.
 	if err := rows.Scan(
-		&vc.ID,
-		&vc.CreateTime,
-		&vc.UpdateTime,
-		&vc.Number,
-		&vc.Name,
+		&scanc.ID,
+		&scanc.CreateTime,
+		&scanc.UpdateTime,
+		&scanc.Number,
+		&scanc.Name,
 	); err != nil {
 		return err
 	}
-	c.ID = strconv.Itoa(vc.ID)
-	c.CreateTime = vc.CreateTime.Time
-	c.UpdateTime = vc.UpdateTime.Time
-	c.Number = vc.Number.String
-	c.Name = vc.Name.String
+	c.ID = strconv.Itoa(scanc.ID)
+	c.CreateTime = scanc.CreateTime.Time
+	c.UpdateTime = scanc.UpdateTime.Time
+	c.Number = scanc.Number.String
+	c.Name = scanc.Name.String
 	return nil
 }
 
@@ -67,21 +67,21 @@ func (c *Card) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vc struct {
+	var scanc struct {
 		ID         string `json:"id,omitempty"`
 		CreateTime int64  `json:"create_time,omitempty"`
 		UpdateTime int64  `json:"update_time,omitempty"`
 		Number     string `json:"number,omitempty"`
 		Name       string `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vc); err != nil {
+	if err := vmap.Decode(&scanc); err != nil {
 		return err
 	}
-	c.ID = vc.ID
-	c.CreateTime = time.Unix(0, vc.CreateTime)
-	c.UpdateTime = time.Unix(0, vc.UpdateTime)
-	c.Number = vc.Number
-	c.Name = vc.Name
+	c.ID = scanc.ID
+	c.CreateTime = time.Unix(0, scanc.CreateTime)
+	c.UpdateTime = time.Unix(0, scanc.UpdateTime)
+	c.Number = scanc.Number
+	c.Name = scanc.Name
 	return nil
 }
 
@@ -137,11 +137,11 @@ type Cards []*Card
 // FromRows scans the sql response data into Cards.
 func (c *Cards) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vc := &Card{}
-		if err := vc.FromRows(rows); err != nil {
+		scanc := &Card{}
+		if err := scanc.FromRows(rows); err != nil {
 			return err
 		}
-		*c = append(*c, vc)
+		*c = append(*c, scanc)
 	}
 	return nil
 }
@@ -152,17 +152,17 @@ func (c *Cards) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vc []struct {
+	var scanc []struct {
 		ID         string `json:"id,omitempty"`
 		CreateTime int64  `json:"create_time,omitempty"`
 		UpdateTime int64  `json:"update_time,omitempty"`
 		Number     string `json:"number,omitempty"`
 		Name       string `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vc); err != nil {
+	if err := vmap.Decode(&scanc); err != nil {
 		return err
 	}
-	for _, v := range vc {
+	for _, v := range scanc {
 		*c = append(*c, &Card{
 			ID:         v.ID,
 			CreateTime: time.Unix(0, v.CreateTime),

entc/integration/ent/comment.go

@@ -30,7 +30,7 @@ type Comment struct {
 
 // FromRows scans the sql response data into Comment.
 func (c *Comment) FromRows(rows *sql.Rows) error {
-	var vc struct {
+	var scanc struct {
 		ID          int
 		UniqueInt   sql.NullInt64
 		UniqueFloat sql.NullFloat64
@@ -38,19 +38,19 @@ func (c *Comment) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `comment.Columns`.
 	if err := rows.Scan(
-		&vc.ID,
-		&vc.UniqueInt,
-		&vc.UniqueFloat,
-		&vc.NillableInt,
+		&scanc.ID,
+		&scanc.UniqueInt,
+		&scanc.UniqueFloat,
+		&scanc.NillableInt,
 	); err != nil {
 		return err
 	}
-	c.ID = strconv.Itoa(vc.ID)
-	c.UniqueInt = int(vc.UniqueInt.Int64)
-	c.UniqueFloat = vc.UniqueFloat.Float64
-	if vc.NillableInt.Valid {
+	c.ID = strconv.Itoa(scanc.ID)
+	c.UniqueInt = int(scanc.UniqueInt.Int64)
+	c.UniqueFloat = scanc.UniqueFloat.Float64
+	if scanc.NillableInt.Valid {
 		c.NillableInt = new(int)
-		*c.NillableInt = int(vc.NillableInt.Int64)
+		*c.NillableInt = int(scanc.NillableInt.Int64)
 	}
 	return nil
 }
@@ -61,19 +61,19 @@ func (c *Comment) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vc struct {
+	var scanc struct {
 		ID          string  `json:"id,omitempty"`
 		UniqueInt   int     `json:"unique_int,omitempty"`
 		UniqueFloat float64 `json:"unique_float,omitempty"`
 		NillableInt *int    `json:"nillable_int,omitempty"`
 	}
-	if err := vmap.Decode(&vc); err != nil {
+	if err := vmap.Decode(&scanc); err != nil {
 		return err
 	}
-	c.ID = vc.ID
-	c.UniqueInt = vc.UniqueInt
-	c.UniqueFloat = vc.UniqueFloat
-	c.NillableInt = vc.NillableInt
+	c.ID = scanc.ID
+	c.UniqueInt = scanc.UniqueInt
+	c.UniqueFloat = scanc.UniqueFloat
+	c.NillableInt = scanc.NillableInt
 	return nil
 }
 
@@ -124,11 +124,11 @@ type Comments []*Comment
 // FromRows scans the sql response data into Comments.
 func (c *Comments) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vc := &Comment{}
-		if err := vc.FromRows(rows); err != nil {
+		scanc := &Comment{}
+		if err := scanc.FromRows(rows); err != nil {
 			return err
 		}
-		*c = append(*c, vc)
+		*c = append(*c, scanc)
 	}
 	return nil
 }
@@ -139,16 +139,16 @@ func (c *Comments) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vc []struct {
+	var scanc []struct {
 		ID          string  `json:"id,omitempty"`
 		UniqueInt   int     `json:"unique_int,omitempty"`
 		UniqueFloat float64 `json:"unique_float,omitempty"`
 		NillableInt *int    `json:"nillable_int,omitempty"`
 	}
-	if err := vmap.Decode(&vc); err != nil {
+	if err := vmap.Decode(&scanc); err != nil {
 		return err
 	}
-	for _, v := range vc {
+	for _, v := range scanc {
 		*c = append(*c, &Comment{
 			ID:          v.ID,
 			UniqueInt:   v.UniqueInt,

entc/integration/ent/fieldtype.go

@@ -59,7 +59,7 @@ type FieldType struct {
 
 // FromRows scans the sql response data into FieldType.
 func (ft *FieldType) FromRows(rows *sql.Rows) error {
-	var vft struct {
+	var scanft struct {
 		ID                    int
 		Int                   sql.NullInt64
 		Int8                  sql.NullInt64
@@ -81,60 +81,60 @@ func (ft *FieldType) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `fieldtype.Columns`.
 	if err := rows.Scan(
-		&vft.ID,
-		&vft.Int,
-		&vft.Int8,
-		&vft.Int16,
-		&vft.Int32,
-		&vft.Int64,
-		&vft.OptionalInt,
-		&vft.OptionalInt8,
-		&vft.OptionalInt16,
-		&vft.OptionalInt32,
-		&vft.OptionalInt64,
-		&vft.NillableInt,
-		&vft.NillableInt8,
-		&vft.NillableInt16,
-		&vft.NillableInt32,
-		&vft.NillableInt64,
-		&vft.ValidateOptionalInt32,
-		&vft.State,
+		&scanft.ID,
+		&scanft.Int,
+		&scanft.Int8,
+		&scanft.Int16,
+		&scanft.Int32,
+		&scanft.Int64,
+		&scanft.OptionalInt,
+		&scanft.OptionalInt8,
+		&scanft.OptionalInt16,
+		&scanft.OptionalInt32,
+		&scanft.OptionalInt64,
+		&scanft.NillableInt,
+		&scanft.NillableInt8,
+		&scanft.NillableInt16,
+		&scanft.NillableInt32,
+		&scanft.NillableInt64,
+		&scanft.ValidateOptionalInt32,
+		&scanft.State,
 	); err != nil {
 		return err
 	}
-	ft.ID = strconv.Itoa(vft.ID)
-	ft.Int = int(vft.Int.Int64)
-	ft.Int8 = int8(vft.Int8.Int64)
-	ft.Int16 = int16(vft.Int16.Int64)
-	ft.Int32 = int32(vft.Int32.Int64)
-	ft.Int64 = vft.Int64.Int64
-	ft.OptionalInt = int(vft.OptionalInt.Int64)
-	ft.OptionalInt8 = int8(vft.OptionalInt8.Int64)
-	ft.OptionalInt16 = int16(vft.OptionalInt16.Int64)
-	ft.OptionalInt32 = int32(vft.OptionalInt32.Int64)
-	ft.OptionalInt64 = vft.OptionalInt64.Int64
-	if vft.NillableInt.Valid {
+	ft.ID = strconv.Itoa(scanft.ID)
+	ft.Int = int(scanft.Int.Int64)
+	ft.Int8 = int8(scanft.Int8.Int64)
+	ft.Int16 = int16(scanft.Int16.Int64)
+	ft.Int32 = int32(scanft.Int32.Int64)
+	ft.Int64 = scanft.Int64.Int64
+	ft.OptionalInt = int(scanft.OptionalInt.Int64)
+	ft.OptionalInt8 = int8(scanft.OptionalInt8.Int64)
+	ft.OptionalInt16 = int16(scanft.OptionalInt16.Int64)
+	ft.OptionalInt32 = int32(scanft.OptionalInt32.Int64)
+	ft.OptionalInt64 = scanft.OptionalInt64.Int64
+	if scanft.NillableInt.Valid {
 		ft.NillableInt = new(int)
-		*ft.NillableInt = int(vft.NillableInt.Int64)
+		*ft.NillableInt = int(scanft.NillableInt.Int64)
 	}
-	if vft.NillableInt8.Valid {
+	if scanft.NillableInt8.Valid {
 		ft.NillableInt8 = new(int8)
-		*ft.NillableInt8 = int8(vft.NillableInt8.Int64)
+		*ft.NillableInt8 = int8(scanft.NillableInt8.Int64)
 	}
-	if vft.NillableInt16.Valid {
+	if scanft.NillableInt16.Valid {
 		ft.NillableInt16 = new(int16)
-		*ft.NillableInt16 = int16(vft.NillableInt16.Int64)
+		*ft.NillableInt16 = int16(scanft.NillableInt16.Int64)
 	}
-	if vft.NillableInt32.Valid {
+	if scanft.NillableInt32.Valid {
 		ft.NillableInt32 = new(int32)
-		*ft.NillableInt32 = int32(vft.NillableInt32.Int64)
+		*ft.NillableInt32 = int32(scanft.NillableInt32.Int64)
 	}
-	if vft.NillableInt64.Valid {
+	if scanft.NillableInt64.Valid {
 		ft.NillableInt64 = new(int64)
-		*ft.NillableInt64 = vft.NillableInt64.Int64
+		*ft.NillableInt64 = scanft.NillableInt64.Int64
 	}
-	ft.ValidateOptionalInt32 = int32(vft.ValidateOptionalInt32.Int64)
-	ft.State = fieldtype.State(vft.State.String)
+	ft.ValidateOptionalInt32 = int32(scanft.ValidateOptionalInt32.Int64)
+	ft.State = fieldtype.State(scanft.State.String)
 	return nil
 }
 
@@ -144,7 +144,7 @@ func (ft *FieldType) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vft struct {
+	var scanft struct {
 		ID                    string          `json:"id,omitempty"`
 		Int                   int             `json:"int,omitempty"`
 		Int8                  int8            `json:"int8,omitempty"`
@@ -164,27 +164,27 @@ func (ft *FieldType) FromResponse(res *gremlin.Response) error {
 		ValidateOptionalInt32 int32           `json:"validate_optional_int32,omitempty"`
 		State                 fieldtype.State `json:"state,omitempty"`
 	}
-	if err := vmap.Decode(&vft); err != nil {
+	if err := vmap.Decode(&scanft); err != nil {
 		return err
 	}
-	ft.ID = vft.ID
-	ft.Int = vft.Int
-	ft.Int8 = vft.Int8
-	ft.Int16 = vft.Int16
-	ft.Int32 = vft.Int32
-	ft.Int64 = vft.Int64
-	ft.OptionalInt = vft.OptionalInt
-	ft.OptionalInt8 = vft.OptionalInt8
-	ft.OptionalInt16 = vft.OptionalInt16
-	ft.OptionalInt32 = vft.OptionalInt32
-	ft.OptionalInt64 = vft.OptionalInt64
-	ft.NillableInt = vft.NillableInt
-	ft.NillableInt8 = vft.NillableInt8
-	ft.NillableInt16 = vft.NillableInt16
-	ft.NillableInt32 = vft.NillableInt32
-	ft.NillableInt64 = vft.NillableInt64
-	ft.ValidateOptionalInt32 = vft.ValidateOptionalInt32
-	ft.State = vft.State
+	ft.ID = scanft.ID
+	ft.Int = scanft.Int
+	ft.Int8 = scanft.Int8
+	ft.Int16 = scanft.Int16
+	ft.Int32 = scanft.Int32
+	ft.Int64 = scanft.Int64
+	ft.OptionalInt = scanft.OptionalInt
+	ft.OptionalInt8 = scanft.OptionalInt8
+	ft.OptionalInt16 = scanft.OptionalInt16
+	ft.OptionalInt32 = scanft.OptionalInt32
+	ft.OptionalInt64 = scanft.OptionalInt64
+	ft.NillableInt = scanft.NillableInt
+	ft.NillableInt8 = scanft.NillableInt8
+	ft.NillableInt16 = scanft.NillableInt16
+	ft.NillableInt32 = scanft.NillableInt32
+	ft.NillableInt64 = scanft.NillableInt64
+	ft.ValidateOptionalInt32 = scanft.ValidateOptionalInt32
+	ft.State = scanft.State
 	return nil
 }
 
@@ -271,11 +271,11 @@ type FieldTypes []*FieldType
 // FromRows scans the sql response data into FieldTypes.
 func (ft *FieldTypes) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vft := &FieldType{}
-		if err := vft.FromRows(rows); err != nil {
+		scanft := &FieldType{}
+		if err := scanft.FromRows(rows); err != nil {
 			return err
 		}
-		*ft = append(*ft, vft)
+		*ft = append(*ft, scanft)
 	}
 	return nil
 }
@@ -286,7 +286,7 @@ func (ft *FieldTypes) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vft []struct {
+	var scanft []struct {
 		ID                    string          `json:"id,omitempty"`
 		Int                   int             `json:"int,omitempty"`
 		Int8                  int8            `json:"int8,omitempty"`
@@ -306,10 +306,10 @@ func (ft *FieldTypes) FromResponse(res *gremlin.Response) error {
 		ValidateOptionalInt32 int32           `json:"validate_optional_int32,omitempty"`
 		State                 fieldtype.State `json:"state,omitempty"`
 	}
-	if err := vmap.Decode(&vft); err != nil {
+	if err := vmap.Decode(&scanft); err != nil {
 		return err
 	}
-	for _, v := range vft {
+	for _, v := range scanft {
 		*ft = append(*ft, &FieldType{
 			ID:                    v.ID,
 			Int:                   v.Int,

entc/integration/ent/file.go

@@ -32,7 +32,7 @@ type File struct {
 
 // FromRows scans the sql response data into File.
 func (f *File) FromRows(rows *sql.Rows) error {
-	var vf struct {
+	var scanf struct {
 		ID    int
 		Size  sql.NullInt64
 		Name  sql.NullString
@@ -41,22 +41,22 @@ func (f *File) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `file.Columns`.
 	if err := rows.Scan(
-		&vf.ID,
-		&vf.Size,
-		&vf.Name,
-		&vf.User,
-		&vf.Group,
+		&scanf.ID,
+		&scanf.Size,
+		&scanf.Name,
+		&scanf.User,
+		&scanf.Group,
 	); err != nil {
 		return err
 	}
-	f.ID = strconv.Itoa(vf.ID)
-	f.Size = int(vf.Size.Int64)
-	f.Name = vf.Name.String
-	if vf.User.Valid {
+	f.ID = strconv.Itoa(scanf.ID)
+	f.Size = int(scanf.Size.Int64)
+	f.Name = scanf.Name.String
+	if scanf.User.Valid {
 		f.User = new(string)
-		*f.User = vf.User.String
+		*f.User = scanf.User.String
 	}
-	f.Group = vf.Group.String
+	f.Group = scanf.Group.String
 	return nil
 }
 
@@ -66,21 +66,21 @@ func (f *File) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vf struct {
+	var scanf struct {
 		ID    string  `json:"id,omitempty"`
 		Size  int     `json:"fsize,omitempty"`
 		Name  string  `json:"name,omitempty"`
 		User  *string `json:"user,omitempty"`
 		Group string  `json:"group,omitempty"`
 	}
-	if err := vmap.Decode(&vf); err != nil {
+	if err := vmap.Decode(&scanf); err != nil {
 		return err
 	}
-	f.ID = vf.ID
-	f.Size = vf.Size
-	f.Name = vf.Name
-	f.User = vf.User
-	f.Group = vf.Group
+	f.ID = scanf.ID
+	f.Size = scanf.Size
+	f.Name = scanf.Name
+	f.User = scanf.User
+	f.Group = scanf.Group
 	return nil
 }
 
@@ -143,11 +143,11 @@ type Files []*File
 // FromRows scans the sql response data into Files.
 func (f *Files) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vf := &File{}
-		if err := vf.FromRows(rows); err != nil {
+		scanf := &File{}
+		if err := scanf.FromRows(rows); err != nil {
 			return err
 		}
-		*f = append(*f, vf)
+		*f = append(*f, scanf)
 	}
 	return nil
 }
@@ -158,17 +158,17 @@ func (f *Files) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vf []struct {
+	var scanf []struct {
 		ID    string  `json:"id,omitempty"`
 		Size  int     `json:"fsize,omitempty"`
 		Name  string  `json:"name,omitempty"`
 		User  *string `json:"user,omitempty"`
 		Group string  `json:"group,omitempty"`
 	}
-	if err := vmap.Decode(&vf); err != nil {
+	if err := vmap.Decode(&scanf); err != nil {
 		return err
 	}
-	for _, v := range vf {
+	for _, v := range scanf {
 		*f = append(*f, &File{
 			ID:    v.ID,
 			Size:  v.Size,

entc/integration/ent/filetype.go

@@ -26,19 +26,19 @@ type FileType struct {
 
 // FromRows scans the sql response data into FileType.
 func (ft *FileType) FromRows(rows *sql.Rows) error {
-	var vft struct {
+	var scanft struct {
 		ID   int
 		Name sql.NullString
 	}
 	// the order here should be the same as in the `filetype.Columns`.
 	if err := rows.Scan(
-		&vft.ID,
-		&vft.Name,
+		&scanft.ID,
+		&scanft.Name,
 	); err != nil {
 		return err
 	}
-	ft.ID = strconv.Itoa(vft.ID)
-	ft.Name = vft.Name.String
+	ft.ID = strconv.Itoa(scanft.ID)
+	ft.Name = scanft.Name.String
 	return nil
 }
 
@@ -48,15 +48,15 @@ func (ft *FileType) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vft struct {
+	var scanft struct {
 		ID   string `json:"id,omitempty"`
 		Name string `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vft); err != nil {
+	if err := vmap.Decode(&scanft); err != nil {
 		return err
 	}
-	ft.ID = vft.ID
-	ft.Name = vft.Name
+	ft.ID = scanft.ID
+	ft.Name = scanft.Name
 	return nil
 }
 
@@ -106,11 +106,11 @@ type FileTypes []*FileType
 // FromRows scans the sql response data into FileTypes.
 func (ft *FileTypes) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vft := &FileType{}
-		if err := vft.FromRows(rows); err != nil {
+		scanft := &FileType{}
+		if err := scanft.FromRows(rows); err != nil {
 			return err
 		}
-		*ft = append(*ft, vft)
+		*ft = append(*ft, scanft)
 	}
 	return nil
 }
@@ -121,14 +121,14 @@ func (ft *FileTypes) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vft []struct {
+	var scanft []struct {
 		ID   string `json:"id,omitempty"`
 		Name string `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vft); err != nil {
+	if err := vmap.Decode(&scanft); err != nil {
 		return err
 	}
-	for _, v := range vft {
+	for _, v := range scanft {
 		*ft = append(*ft, &FileType{
 			ID:   v.ID,
 			Name: v.Name,

entc/integration/ent/group.go

@@ -35,7 +35,7 @@ type Group struct {
 
 // FromRows scans the sql response data into Group.
 func (gr *Group) FromRows(rows *sql.Rows) error {
-	var vgr struct {
+	var scangr struct {
 		ID       int
 		Active   sql.NullBool
 		Expire   sql.NullTime
@@ -45,24 +45,24 @@ func (gr *Group) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `group.Columns`.
 	if err := rows.Scan(
-		&vgr.ID,
-		&vgr.Active,
-		&vgr.Expire,
-		&vgr.Type,
-		&vgr.MaxUsers,
-		&vgr.Name,
+		&scangr.ID,
+		&scangr.Active,
+		&scangr.Expire,
+		&scangr.Type,
+		&scangr.MaxUsers,
+		&scangr.Name,
 	); err != nil {
 		return err
 	}
-	gr.ID = strconv.Itoa(vgr.ID)
-	gr.Active = vgr.Active.Bool
-	gr.Expire = vgr.Expire.Time
-	if vgr.Type.Valid {
+	gr.ID = strconv.Itoa(scangr.ID)
+	gr.Active = scangr.Active.Bool
+	gr.Expire = scangr.Expire.Time
+	if scangr.Type.Valid {
 		gr.Type = new(string)
-		*gr.Type = vgr.Type.String
+		*gr.Type = scangr.Type.String
 	}
-	gr.MaxUsers = int(vgr.MaxUsers.Int64)
-	gr.Name = vgr.Name.String
+	gr.MaxUsers = int(scangr.MaxUsers.Int64)
+	gr.Name = scangr.Name.String
 	return nil
 }
 
@@ -72,7 +72,7 @@ func (gr *Group) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vgr struct {
+	var scangr struct {
 		ID       string  `json:"id,omitempty"`
 		Active   bool    `json:"active,omitempty"`
 		Expire   int64   `json:"expire,omitempty"`
@@ -80,15 +80,15 @@ func (gr *Group) FromResponse(res *gremlin.Response) error {
 		MaxUsers int     `json:"max_users,omitempty"`
 		Name     string  `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vgr); err != nil {
+	if err := vmap.Decode(&scangr); err != nil {
 		return err
 	}
-	gr.ID = vgr.ID
-	gr.Active = vgr.Active
-	gr.Expire = time.Unix(0, vgr.Expire)
-	gr.Type = vgr.Type
-	gr.MaxUsers = vgr.MaxUsers
-	gr.Name = vgr.Name
+	gr.ID = scangr.ID
+	gr.Active = scangr.Active
+	gr.Expire = time.Unix(0, scangr.Expire)
+	gr.Type = scangr.Type
+	gr.MaxUsers = scangr.MaxUsers
+	gr.Name = scangr.Name
 	return nil
 }
 
@@ -163,11 +163,11 @@ type Groups []*Group
 // FromRows scans the sql response data into Groups.
 func (gr *Groups) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vgr := &Group{}
-		if err := vgr.FromRows(rows); err != nil {
+		scangr := &Group{}
+		if err := scangr.FromRows(rows); err != nil {
 			return err
 		}
-		*gr = append(*gr, vgr)
+		*gr = append(*gr, scangr)
 	}
 	return nil
 }
@@ -178,7 +178,7 @@ func (gr *Groups) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vgr []struct {
+	var scangr []struct {
 		ID       string  `json:"id,omitempty"`
 		Active   bool    `json:"active,omitempty"`
 		Expire   int64   `json:"expire,omitempty"`
@@ -186,10 +186,10 @@ func (gr *Groups) FromResponse(res *gremlin.Response) error {
 		MaxUsers int     `json:"max_users,omitempty"`
 		Name     string  `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vgr); err != nil {
+	if err := vmap.Decode(&scangr); err != nil {
 		return err
 	}
-	for _, v := range vgr {
+	for _, v := range scangr {
 		*gr = append(*gr, &Group{
 			ID:       v.ID,
 			Active:   v.Active,

entc/integration/ent/groupinfo.go

@@ -28,22 +28,22 @@ type GroupInfo struct {
 
 // FromRows scans the sql response data into GroupInfo.
 func (gi *GroupInfo) FromRows(rows *sql.Rows) error {
-	var vgi struct {
+	var scangi struct {
 		ID       int
 		Desc     sql.NullString
 		MaxUsers sql.NullInt64
 	}
 	// the order here should be the same as in the `groupinfo.Columns`.
 	if err := rows.Scan(
-		&vgi.ID,
-		&vgi.Desc,
-		&vgi.MaxUsers,
+		&scangi.ID,
+		&scangi.Desc,
+		&scangi.MaxUsers,
 	); err != nil {
 		return err
 	}
-	gi.ID = strconv.Itoa(vgi.ID)
-	gi.Desc = vgi.Desc.String
-	gi.MaxUsers = int(vgi.MaxUsers.Int64)
+	gi.ID = strconv.Itoa(scangi.ID)
+	gi.Desc = scangi.Desc.String
+	gi.MaxUsers = int(scangi.MaxUsers.Int64)
 	return nil
 }
 
@@ -53,17 +53,17 @@ func (gi *GroupInfo) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vgi struct {
+	var scangi struct {
 		ID       string `json:"id,omitempty"`
 		Desc     string `json:"desc,omitempty"`
 		MaxUsers int    `json:"max_users,omitempty"`
 	}
-	if err := vmap.Decode(&vgi); err != nil {
+	if err := vmap.Decode(&scangi); err != nil {
 		return err
 	}
-	gi.ID = vgi.ID
-	gi.Desc = vgi.Desc
-	gi.MaxUsers = vgi.MaxUsers
+	gi.ID = scangi.ID
+	gi.Desc = scangi.Desc
+	gi.MaxUsers = scangi.MaxUsers
 	return nil
 }
 
@@ -115,11 +115,11 @@ type GroupInfos []*GroupInfo
 // FromRows scans the sql response data into GroupInfos.
 func (gi *GroupInfos) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vgi := &GroupInfo{}
-		if err := vgi.FromRows(rows); err != nil {
+		scangi := &GroupInfo{}
+		if err := scangi.FromRows(rows); err != nil {
 			return err
 		}
-		*gi = append(*gi, vgi)
+		*gi = append(*gi, scangi)
 	}
 	return nil
 }
@@ -130,15 +130,15 @@ func (gi *GroupInfos) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vgi []struct {
+	var scangi []struct {
 		ID       string `json:"id,omitempty"`
 		Desc     string `json:"desc,omitempty"`
 		MaxUsers int    `json:"max_users,omitempty"`
 	}
-	if err := vmap.Decode(&vgi); err != nil {
+	if err := vmap.Decode(&scangi); err != nil {
 		return err
 	}
-	for _, v := range vgi {
+	for _, v := range scangi {
 		*gi = append(*gi, &GroupInfo{
 			ID:       v.ID,
 			Desc:     v.Desc,

entc/integration/ent/item.go

@@ -24,16 +24,16 @@ type Item struct {
 
 // FromRows scans the sql response data into Item.
 func (i *Item) FromRows(rows *sql.Rows) error {
-	var vi struct {
+	var scani struct {
 		ID int
 	}
 	// the order here should be the same as in the `item.Columns`.
 	if err := rows.Scan(
-		&vi.ID,
+		&scani.ID,
 	); err != nil {
 		return err
 	}
-	i.ID = strconv.Itoa(vi.ID)
+	i.ID = strconv.Itoa(scani.ID)
 	return nil
 }
 
@@ -43,13 +43,13 @@ func (i *Item) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vi struct {
+	var scani struct {
 		ID string `json:"id,omitempty"`
 	}
-	if err := vmap.Decode(&vi); err != nil {
+	if err := vmap.Decode(&scani); err != nil {
 		return err
 	}
-	i.ID = vi.ID
+	i.ID = scani.ID
 	return nil
 }
 
@@ -92,11 +92,11 @@ type Items []*Item
 // FromRows scans the sql response data into Items.
 func (i *Items) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vi := &Item{}
-		if err := vi.FromRows(rows); err != nil {
+		scani := &Item{}
+		if err := scani.FromRows(rows); err != nil {
 			return err
 		}
-		*i = append(*i, vi)
+		*i = append(*i, scani)
 	}
 	return nil
 }
@@ -107,13 +107,13 @@ func (i *Items) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vi []struct {
+	var scani []struct {
 		ID string `json:"id,omitempty"`
 	}
-	if err := vmap.Decode(&vi); err != nil {
+	if err := vmap.Decode(&scani); err != nil {
 		return err
 	}
-	for _, v := range vi {
+	for _, v := range scani {
 		*i = append(*i, &Item{
 			ID: v.ID,
 		})

entc/integration/ent/node.go

@@ -26,19 +26,19 @@ type Node struct {
 
 // FromRows scans the sql response data into Node.
 func (n *Node) FromRows(rows *sql.Rows) error {
-	var vn struct {
+	var scann struct {
 		ID    int
 		Value sql.NullInt64
 	}
 	// the order here should be the same as in the `node.Columns`.
 	if err := rows.Scan(
-		&vn.ID,
-		&vn.Value,
+		&scann.ID,
+		&scann.Value,
 	); err != nil {
 		return err
 	}
-	n.ID = strconv.Itoa(vn.ID)
-	n.Value = int(vn.Value.Int64)
+	n.ID = strconv.Itoa(scann.ID)
+	n.Value = int(scann.Value.Int64)
 	return nil
 }
 
@@ -48,15 +48,15 @@ func (n *Node) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vn struct {
+	var scann struct {
 		ID    string `json:"id,omitempty"`
 		Value int    `json:"value,omitempty"`
 	}
-	if err := vmap.Decode(&vn); err != nil {
+	if err := vmap.Decode(&scann); err != nil {
 		return err
 	}
-	n.ID = vn.ID
-	n.Value = vn.Value
+	n.ID = scann.ID
+	n.Value = scann.Value
 	return nil
 }
 
@@ -111,11 +111,11 @@ type Nodes []*Node
 // FromRows scans the sql response data into Nodes.
 func (n *Nodes) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vn := &Node{}
-		if err := vn.FromRows(rows); err != nil {
+		scann := &Node{}
+		if err := scann.FromRows(rows); err != nil {
 			return err
 		}
-		*n = append(*n, vn)
+		*n = append(*n, scann)
 	}
 	return nil
 }
@@ -126,14 +126,14 @@ func (n *Nodes) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vn []struct {
+	var scann []struct {
 		ID    string `json:"id,omitempty"`
 		Value int    `json:"value,omitempty"`
 	}
-	if err := vmap.Decode(&vn); err != nil {
+	if err := vmap.Decode(&scann); err != nil {
 		return err
 	}
-	for _, v := range vn {
+	for _, v := range scann {
 		*n = append(*n, &Node{
 			ID:    v.ID,
 			Value: v.Value,

entc/integration/ent/pet.go

@@ -26,19 +26,19 @@ type Pet struct {
 
 // FromRows scans the sql response data into Pet.
 func (pe *Pet) FromRows(rows *sql.Rows) error {
-	var vpe struct {
+	var scanpe struct {
 		ID   int
 		Name sql.NullString
 	}
 	// the order here should be the same as in the `pet.Columns`.
 	if err := rows.Scan(
-		&vpe.ID,
-		&vpe.Name,
+		&scanpe.ID,
+		&scanpe.Name,
 	); err != nil {
 		return err
 	}
-	pe.ID = strconv.Itoa(vpe.ID)
-	pe.Name = vpe.Name.String
+	pe.ID = strconv.Itoa(scanpe.ID)
+	pe.Name = scanpe.Name.String
 	return nil
 }
 
@@ -48,15 +48,15 @@ func (pe *Pet) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vpe struct {
+	var scanpe struct {
 		ID   string `json:"id,omitempty"`
 		Name string `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vpe); err != nil {
+	if err := vmap.Decode(&scanpe); err != nil {
 		return err
 	}
-	pe.ID = vpe.ID
-	pe.Name = vpe.Name
+	pe.ID = scanpe.ID
+	pe.Name = scanpe.Name
 	return nil
 }
 
@@ -111,11 +111,11 @@ type Pets []*Pet
 // FromRows scans the sql response data into Pets.
 func (pe *Pets) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vpe := &Pet{}
-		if err := vpe.FromRows(rows); err != nil {
+		scanpe := &Pet{}
+		if err := scanpe.FromRows(rows); err != nil {
 			return err
 		}
-		*pe = append(*pe, vpe)
+		*pe = append(*pe, scanpe)
 	}
 	return nil
 }
@@ -126,14 +126,14 @@ func (pe *Pets) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vpe []struct {
+	var scanpe []struct {
 		ID   string `json:"id,omitempty"`
 		Name string `json:"name,omitempty"`
 	}
-	if err := vmap.Decode(&vpe); err != nil {
+	if err := vmap.Decode(&scanpe); err != nil {
 		return err
 	}
-	for _, v := range vpe {
+	for _, v := range scanpe {
 		*pe = append(*pe, &Pet{
 			ID:   v.ID,
 			Name: v.Name,

entc/integration/ent/user.go

@@ -36,7 +36,7 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID       int
 		Age      sql.NullInt64
 		Name     sql.NullString
@@ -47,23 +47,23 @@ func (u *User) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
-		&vu.Age,
-		&vu.Name,
-		&vu.Last,
-		&vu.Nickname,
-		&vu.Phone,
-		&vu.Password,
+		&scanu.ID,
+		&scanu.Age,
+		&scanu.Name,
+		&scanu.Last,
+		&scanu.Nickname,
+		&scanu.Phone,
+		&scanu.Password,
 	); err != nil {
 		return err
 	}
-	u.ID = strconv.Itoa(vu.ID)
-	u.Age = int(vu.Age.Int64)
-	u.Name = vu.Name.String
-	u.Last = vu.Last.String
-	u.Nickname = vu.Nickname.String
-	u.Phone = vu.Phone.String
-	u.Password = vu.Password.String
+	u.ID = strconv.Itoa(scanu.ID)
+	u.Age = int(scanu.Age.Int64)
+	u.Name = scanu.Name.String
+	u.Last = scanu.Last.String
+	u.Nickname = scanu.Nickname.String
+	u.Phone = scanu.Phone.String
+	u.Password = scanu.Password.String
 	return nil
 }
 
@@ -73,7 +73,7 @@ func (u *User) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vu struct {
+	var scanu struct {
 		ID       string `json:"id,omitempty"`
 		Age      int    `json:"age,omitempty"`
 		Name     string `json:"name,omitempty"`
@@ -82,16 +82,16 @@ func (u *User) FromResponse(res *gremlin.Response) error {
 		Phone    string `json:"phone,omitempty"`
 		Password string `json:"password,omitempty"`
 	}
-	if err := vmap.Decode(&vu); err != nil {
+	if err := vmap.Decode(&scanu); err != nil {
 		return err
 	}
-	u.ID = vu.ID
-	u.Age = vu.Age
-	u.Name = vu.Name
-	u.Last = vu.Last
-	u.Nickname = vu.Nickname
-	u.Phone = vu.Phone
-	u.Password = vu.Password
+	u.ID = scanu.ID
+	u.Age = scanu.Age
+	u.Name = scanu.Name
+	u.Last = scanu.Last
+	u.Nickname = scanu.Nickname
+	u.Phone = scanu.Phone
+	u.Password = scanu.Password
 	return nil
 }
 
@@ -200,11 +200,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }
@@ -215,7 +215,7 @@ func (u *Users) FromResponse(res *gremlin.Response) error {
 	if err != nil {
 		return err
 	}
-	var vu []struct {
+	var scanu []struct {
 		ID       string `json:"id,omitempty"`
 		Age      int    `json:"age,omitempty"`
 		Name     string `json:"name,omitempty"`
@@ -224,10 +224,10 @@ func (u *Users) FromResponse(res *gremlin.Response) error {
 		Phone    string `json:"phone,omitempty"`
 		Password string `json:"password,omitempty"`
 	}
-	if err := vmap.Decode(&vu); err != nil {
+	if err := vmap.Decode(&scanu); err != nil {
 		return err
 	}
-	for _, v := range vu {
+	for _, v := range scanu {
 		*u = append(*u, &User{
 			ID:       v.ID,
 			Age:      v.Age,

entc/integration/idtype/ent/user.go

@@ -24,19 +24,19 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID   uint64
 		Name sql.NullString
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
-		&vu.Name,
+		&scanu.ID,
+		&scanu.Name,
 	); err != nil {
 		return err
 	}
-	u.ID = vu.ID
-	u.Name = vu.Name.String
+	u.ID = scanu.ID
+	u.Name = scanu.Name.String
 	return nil
 }
 
@@ -90,11 +90,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }

entc/integration/json/ent/user.go

@@ -37,7 +37,7 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID      int
 		URL     []byte
 		Raw     []byte
@@ -48,43 +48,43 @@ func (u *User) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
-		&vu.URL,
-		&vu.Raw,
-		&vu.Dirs,
-		&vu.Ints,
-		&vu.Floats,
-		&vu.Strings,
+		&scanu.ID,
+		&scanu.URL,
+		&scanu.Raw,
+		&scanu.Dirs,
+		&scanu.Ints,
+		&scanu.Floats,
+		&scanu.Strings,
 	); err != nil {
 		return err
 	}
-	u.ID = vu.ID
-	if value := vu.URL; len(value) > 0 {
+	u.ID = scanu.ID
+	if value := scanu.URL; len(value) > 0 {
 		if err := json.Unmarshal(value, &u.URL); err != nil {
 			return fmt.Errorf("unmarshal field url: %v", err)
 		}
 	}
-	if value := vu.Raw; len(value) > 0 {
+	if value := scanu.Raw; len(value) > 0 {
 		if err := json.Unmarshal(value, &u.Raw); err != nil {
 			return fmt.Errorf("unmarshal field raw: %v", err)
 		}
 	}
-	if value := vu.Dirs; len(value) > 0 {
+	if value := scanu.Dirs; len(value) > 0 {
 		if err := json.Unmarshal(value, &u.Dirs); err != nil {
 			return fmt.Errorf("unmarshal field dirs: %v", err)
 		}
 	}
-	if value := vu.Ints; len(value) > 0 {
+	if value := scanu.Ints; len(value) > 0 {
 		if err := json.Unmarshal(value, &u.Ints); err != nil {
 			return fmt.Errorf("unmarshal field ints: %v", err)
 		}
 	}
-	if value := vu.Floats; len(value) > 0 {
+	if value := scanu.Floats; len(value) > 0 {
 		if err := json.Unmarshal(value, &u.Floats); err != nil {
 			return fmt.Errorf("unmarshal field floats: %v", err)
 		}
 	}
-	if value := vu.Strings; len(value) > 0 {
+	if value := scanu.Strings; len(value) > 0 {
 		if err := json.Unmarshal(value, &u.Strings); err != nil {
 			return fmt.Errorf("unmarshal field strings: %v", err)
 		}
@@ -137,11 +137,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }

entc/integration/migrate/entv1/user.go

@@ -35,7 +35,7 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID      int
 		Age     sql.NullInt64
 		Name    sql.NullString
@@ -46,23 +46,23 @@ func (u *User) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
-		&vu.Age,
-		&vu.Name,
-		&vu.Address,
-		&vu.Renamed,
-		&vu.Blob,
-		&vu.State,
+		&scanu.ID,
+		&scanu.Age,
+		&scanu.Name,
+		&scanu.Address,
+		&scanu.Renamed,
+		&scanu.Blob,
+		&scanu.State,
 	); err != nil {
 		return err
 	}
-	u.ID = vu.ID
-	u.Age = int32(vu.Age.Int64)
-	u.Name = vu.Name.String
-	u.Address = vu.Address.String
-	u.Renamed = vu.Renamed.String
-	u.Blob = vu.Blob
-	u.State = user.State(vu.State.String)
+	u.ID = scanu.ID
+	u.Age = int32(scanu.Age.Int64)
+	u.Name = scanu.Name.String
+	u.Address = scanu.Address.String
+	u.Renamed = scanu.Renamed.String
+	u.Blob = scanu.Blob
+	u.State = user.State(scanu.State.String)
 	return nil
 }
 
@@ -111,11 +111,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }

entc/integration/migrate/entv2/group.go

@@ -22,16 +22,16 @@ type Group struct {
 
 // FromRows scans the sql response data into Group.
 func (gr *Group) FromRows(rows *sql.Rows) error {
-	var vgr struct {
+	var scangr struct {
 		ID int
 	}
 	// the order here should be the same as in the `group.Columns`.
 	if err := rows.Scan(
-		&vgr.ID,
+		&scangr.ID,
 	); err != nil {
 		return err
 	}
-	gr.ID = vgr.ID
+	gr.ID = scangr.ID
 	return nil
 }
 
@@ -68,11 +68,11 @@ type Groups []*Group
 // FromRows scans the sql response data into Groups.
 func (gr *Groups) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vgr := &Group{}
-		if err := vgr.FromRows(rows); err != nil {
+		scangr := &Group{}
+		if err := scangr.FromRows(rows); err != nil {
 			return err
 		}
-		*gr = append(*gr, vgr)
+		*gr = append(*gr, scangr)
 	}
 	return nil
 }

entc/integration/migrate/entv2/pet.go

@@ -22,16 +22,16 @@ type Pet struct {
 
 // FromRows scans the sql response data into Pet.
 func (pe *Pet) FromRows(rows *sql.Rows) error {
-	var vpe struct {
+	var scanpe struct {
 		ID int
 	}
 	// the order here should be the same as in the `pet.Columns`.
 	if err := rows.Scan(
-		&vpe.ID,
+		&scanpe.ID,
 	); err != nil {
 		return err
 	}
-	pe.ID = vpe.ID
+	pe.ID = scanpe.ID
 	return nil
 }
 
@@ -68,11 +68,11 @@ type Pets []*Pet
 // FromRows scans the sql response data into Pets.
 func (pe *Pets) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vpe := &Pet{}
-		if err := vpe.FromRows(rows); err != nil {
+		scanpe := &Pet{}
+		if err := scanpe.FromRows(rows); err != nil {
 			return err
 		}
-		*pe = append(*pe, vpe)
+		*pe = append(*pe, scanpe)
 	}
 	return nil
 }

entc/integration/migrate/entv2/user.go

@@ -39,7 +39,7 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID      int
 		Age     sql.NullInt64
 		Name    sql.NullString
@@ -52,27 +52,27 @@ func (u *User) FromRows(rows *sql.Rows) error {
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
-		&vu.Age,
-		&vu.Name,
-		&vu.Phone,
-		&vu.Buffer,
-		&vu.Title,
-		&vu.NewName,
-		&vu.Blob,
-		&vu.State,
+		&scanu.ID,
+		&scanu.Age,
+		&scanu.Name,
+		&scanu.Phone,
+		&scanu.Buffer,
+		&scanu.Title,
+		&scanu.NewName,
+		&scanu.Blob,
+		&scanu.State,
 	); err != nil {
 		return err
 	}
-	u.ID = vu.ID
-	u.Age = int(vu.Age.Int64)
-	u.Name = vu.Name.String
-	u.Phone = vu.Phone.String
-	u.Buffer = vu.Buffer
-	u.Title = vu.Title.String
-	u.NewName = vu.NewName.String
-	u.Blob = vu.Blob
-	u.State = user.State(vu.State.String)
+	u.ID = scanu.ID
+	u.Age = int(scanu.Age.Int64)
+	u.Name = scanu.Name.String
+	u.Phone = scanu.Phone.String
+	u.Buffer = scanu.Buffer
+	u.Title = scanu.Title.String
+	u.NewName = scanu.NewName.String
+	u.Blob = scanu.Blob
+	u.State = user.State(scanu.State.String)
 	return nil
 }
 
@@ -125,11 +125,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }

entc/integration/template/ent/group.go

@@ -24,19 +24,19 @@ type Group struct {
 
 // FromRows scans the sql response data into Group.
 func (gr *Group) FromRows(rows *sql.Rows) error {
-	var vgr struct {
+	var scangr struct {
 		ID       int
 		MaxUsers sql.NullInt64
 	}
 	// the order here should be the same as in the `group.Columns`.
 	if err := rows.Scan(
-		&vgr.ID,
-		&vgr.MaxUsers,
+		&scangr.ID,
+		&scangr.MaxUsers,
 	); err != nil {
 		return err
 	}
-	gr.ID = vgr.ID
-	gr.MaxUsers = int(vgr.MaxUsers.Int64)
+	gr.ID = scangr.ID
+	gr.MaxUsers = int(scangr.MaxUsers.Int64)
 	return nil
 }
 
@@ -75,11 +75,11 @@ type Groups []*Group
 // FromRows scans the sql response data into Groups.
 func (gr *Groups) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vgr := &Group{}
-		if err := vgr.FromRows(rows); err != nil {
+		scangr := &Group{}
+		if err := scangr.FromRows(rows); err != nil {
 			return err
 		}
-		*gr = append(*gr, vgr)
+		*gr = append(*gr, scangr)
 	}
 	return nil
 }

entc/integration/template/ent/pet.go

@@ -27,24 +27,24 @@ type Pet struct {
 
 // FromRows scans the sql response data into Pet.
 func (pe *Pet) FromRows(rows *sql.Rows) error {
-	var vpe struct {
+	var scanpe struct {
 		ID         int
 		Age        sql.NullInt64
 		LicensedAt sql.NullTime
 	}
 	// the order here should be the same as in the `pet.Columns`.
 	if err := rows.Scan(
-		&vpe.ID,
-		&vpe.Age,
-		&vpe.LicensedAt,
+		&scanpe.ID,
+		&scanpe.Age,
+		&scanpe.LicensedAt,
 	); err != nil {
 		return err
 	}
-	pe.ID = vpe.ID
-	pe.Age = int(vpe.Age.Int64)
-	if vpe.LicensedAt.Valid {
+	pe.ID = scanpe.ID
+	pe.Age = int(scanpe.Age.Int64)
+	if scanpe.LicensedAt.Valid {
 		pe.LicensedAt = new(time.Time)
-		*pe.LicensedAt = vpe.LicensedAt.Time
+		*pe.LicensedAt = scanpe.LicensedAt.Time
 	}
 	return nil
 }
@@ -93,11 +93,11 @@ type Pets []*Pet
 // FromRows scans the sql response data into Pets.
 func (pe *Pets) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vpe := &Pet{}
-		if err := vpe.FromRows(rows); err != nil {
+		scanpe := &Pet{}
+		if err := scanpe.FromRows(rows); err != nil {
 			return err
 		}
-		*pe = append(*pe, vpe)
+		*pe = append(*pe, scanpe)
 	}
 	return nil
 }

entc/integration/template/ent/user.go

@@ -24,19 +24,19 @@ type User struct {
 
 // FromRows scans the sql response data into User.
 func (u *User) FromRows(rows *sql.Rows) error {
-	var vu struct {
+	var scanu struct {
 		ID   int
 		Name sql.NullString
 	}
 	// the order here should be the same as in the `user.Columns`.
 	if err := rows.Scan(
-		&vu.ID,
-		&vu.Name,
+		&scanu.ID,
+		&scanu.Name,
 	); err != nil {
 		return err
 	}
-	u.ID = vu.ID
-	u.Name = vu.Name.String
+	u.ID = scanu.ID
+	u.Name = scanu.Name.String
 	return nil
 }
 
@@ -85,11 +85,11 @@ type Users []*User
 // FromRows scans the sql response data into Users.
 func (u *Users) FromRows(rows *sql.Rows) error {
 	for rows.Next() {
-		vu := &User{}
-		if err := vu.FromRows(rows); err != nil {
+		scanu := &User{}
+		if err := scanu.FromRows(rows); err != nil {
 			return err
 		}
-		*u = append(*u, vu)
+		*u = append(*u, scanu)
 	}
 	return nil
 }