entc/gen: count id field in mixins (#515)

Fixes #512

entc/integration/customid/ent/car.go

@@ -20,6 +20,10 @@ type Car struct {
 	config `json:"-"`
 	// ID of the ent.
 	ID int `json:"id,omitempty"`
+	// BeforeID holds the value of the "before_id" field.
+	BeforeID float64 `json:"before_id,omitempty"`
+	// AfterID holds the value of the "after_id" field.
+	AfterID float64 `json:"after_id,omitempty"`
 	// Model holds the value of the "model" field.
 	Model string `json:"model,omitempty"`
 	// Edges holds the relations/edges for other nodes in the graph.
@@ -54,8 +58,10 @@ func (e CarEdges) OwnerOrErr() (*Pet, error) {
 // scanValues returns the types for scanning values from sql.Rows.
 func (*Car) scanValues() []interface{} {
 	return []interface{}{
-		&sql.NullInt64{},  // id
-		&sql.NullString{}, // model
+		&sql.NullInt64{},   // id
+		&sql.NullFloat64{}, // before_id
+		&sql.NullFloat64{}, // after_id
+		&sql.NullString{},  // model
 	}
 }
 
@@ -78,12 +84,22 @@ func (c *Car) assignValues(values ...interface{}) error {
 	}
 	c.ID = int(value.Int64)
 	values = values[1:]
-	if value, ok := values[0].(*sql.NullString); !ok {
-		return fmt.Errorf("unexpected type %T for field model", values[0])
+	if value, ok := values[0].(*sql.NullFloat64); !ok {
+		return fmt.Errorf("unexpected type %T for field before_id", values[0])
+	} else if value.Valid {
+		c.BeforeID = value.Float64
+	}
+	if value, ok := values[1].(*sql.NullFloat64); !ok {
+		return fmt.Errorf("unexpected type %T for field after_id", values[1])
+	} else if value.Valid {
+		c.AfterID = value.Float64
+	}
+	if value, ok := values[2].(*sql.NullString); !ok {
+		return fmt.Errorf("unexpected type %T for field model", values[2])
 	} else if value.Valid {
 		c.Model = value.String
 	}
-	values = values[1:]
+	values = values[3:]
 	if len(values) == len(car.ForeignKeys) {
 		if value, ok := values[0].(*sql.NullString); !ok {
 			return fmt.Errorf("unexpected type %T for field pet_cars", values[0])
@@ -123,6 +139,10 @@ func (c *Car) String() string {
 	var builder strings.Builder
 	builder.WriteString("Car(")
 	builder.WriteString(fmt.Sprintf("id=%v", c.ID))
+	builder.WriteString(", before_id=")
+	builder.WriteString(fmt.Sprintf("%v", c.BeforeID))
+	builder.WriteString(", after_id=")
+	builder.WriteString(fmt.Sprintf("%v", c.AfterID))
 	builder.WriteString(", model=")
 	builder.WriteString(c.Model)
 	builder.WriteByte(')')

entc/integration/customid/ent/car/car.go

@@ -11,6 +11,10 @@ const (
 	Label = "car"
 	// FieldID holds the string denoting the id field in the database.
 	FieldID = "id"
+	// FieldBeforeID holds the string denoting the before_id field in the database.
+	FieldBeforeID = "before_id"
+	// FieldAfterID holds the string denoting the after_id field in the database.
+	FieldAfterID = "after_id"
 	// FieldModel holds the string denoting the model field in the database.
 	FieldModel = "model"
 
@@ -31,6 +35,8 @@ const (
 // Columns holds all SQL columns for car fields.
 var Columns = []string{
 	FieldID,
+	FieldBeforeID,
+	FieldAfterID,
 	FieldModel,
 }
 
@@ -38,3 +44,12 @@ var Columns = []string{
 var ForeignKeys = []string{
 	"pet_cars",
 }
+
+var (
+	// BeforeIDValidator is a validator for the "before_id" field. It is called by the builders before save.
+	BeforeIDValidator func(float64) error
+	// AfterIDValidator is a validator for the "after_id" field. It is called by the builders before save.
+	AfterIDValidator func(float64) error
+	// IDValidator is a validator for the "id" field. It is called by the builders before save.
+	IDValidator func(int) error
+)

entc/integration/customid/ent/car/where.go

@@ -95,6 +95,20 @@ func IDLTE(id int) predicate.Car {
 	})
 }
 
+// BeforeID applies equality check predicate on the "before_id" field. It's identical to BeforeIDEQ.
+func BeforeID(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldBeforeID), v))
+	})
+}
+
+// AfterID applies equality check predicate on the "after_id" field. It's identical to AfterIDEQ.
+func AfterID(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldAfterID), v))
+	})
+}
+
 // Model applies equality check predicate on the "model" field. It's identical to ModelEQ.
 func Model(v string) predicate.Car {
 	return predicate.Car(func(s *sql.Selector) {
@@ -102,6 +116,186 @@ func Model(v string) predicate.Car {
 	})
 }
 
+// BeforeIDEQ applies the EQ predicate on the "before_id" field.
+func BeforeIDEQ(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldBeforeID), v))
+	})
+}
+
+// BeforeIDNEQ applies the NEQ predicate on the "before_id" field.
+func BeforeIDNEQ(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldBeforeID), v))
+	})
+}
+
+// BeforeIDIn applies the In predicate on the "before_id" field.
+func BeforeIDIn(vs ...float64) predicate.Car {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Car(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.In(s.C(FieldBeforeID), v...))
+	})
+}
+
+// BeforeIDNotIn applies the NotIn predicate on the "before_id" field.
+func BeforeIDNotIn(vs ...float64) predicate.Car {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Car(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.NotIn(s.C(FieldBeforeID), v...))
+	})
+}
+
+// BeforeIDGT applies the GT predicate on the "before_id" field.
+func BeforeIDGT(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldBeforeID), v))
+	})
+}
+
+// BeforeIDGTE applies the GTE predicate on the "before_id" field.
+func BeforeIDGTE(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldBeforeID), v))
+	})
+}
+
+// BeforeIDLT applies the LT predicate on the "before_id" field.
+func BeforeIDLT(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldBeforeID), v))
+	})
+}
+
+// BeforeIDLTE applies the LTE predicate on the "before_id" field.
+func BeforeIDLTE(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldBeforeID), v))
+	})
+}
+
+// BeforeIDIsNil applies the IsNil predicate on the "before_id" field.
+func BeforeIDIsNil() predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.IsNull(s.C(FieldBeforeID)))
+	})
+}
+
+// BeforeIDNotNil applies the NotNil predicate on the "before_id" field.
+func BeforeIDNotNil() predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.NotNull(s.C(FieldBeforeID)))
+	})
+}
+
+// AfterIDEQ applies the EQ predicate on the "after_id" field.
+func AfterIDEQ(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.EQ(s.C(FieldAfterID), v))
+	})
+}
+
+// AfterIDNEQ applies the NEQ predicate on the "after_id" field.
+func AfterIDNEQ(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.NEQ(s.C(FieldAfterID), v))
+	})
+}
+
+// AfterIDIn applies the In predicate on the "after_id" field.
+func AfterIDIn(vs ...float64) predicate.Car {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Car(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.In(s.C(FieldAfterID), v...))
+	})
+}
+
+// AfterIDNotIn applies the NotIn predicate on the "after_id" field.
+func AfterIDNotIn(vs ...float64) predicate.Car {
+	v := make([]interface{}, len(vs))
+	for i := range v {
+		v[i] = vs[i]
+	}
+	return predicate.Car(func(s *sql.Selector) {
+		// if not arguments were provided, append the FALSE constants,
+		// since we can't apply "IN ()". This will make this predicate falsy.
+		if len(v) == 0 {
+			s.Where(sql.False())
+			return
+		}
+		s.Where(sql.NotIn(s.C(FieldAfterID), v...))
+	})
+}
+
+// AfterIDGT applies the GT predicate on the "after_id" field.
+func AfterIDGT(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.GT(s.C(FieldAfterID), v))
+	})
+}
+
+// AfterIDGTE applies the GTE predicate on the "after_id" field.
+func AfterIDGTE(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.GTE(s.C(FieldAfterID), v))
+	})
+}
+
+// AfterIDLT applies the LT predicate on the "after_id" field.
+func AfterIDLT(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.LT(s.C(FieldAfterID), v))
+	})
+}
+
+// AfterIDLTE applies the LTE predicate on the "after_id" field.
+func AfterIDLTE(v float64) predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.LTE(s.C(FieldAfterID), v))
+	})
+}
+
+// AfterIDIsNil applies the IsNil predicate on the "after_id" field.
+func AfterIDIsNil() predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.IsNull(s.C(FieldAfterID)))
+	})
+}
+
+// AfterIDNotNil applies the NotNil predicate on the "after_id" field.
+func AfterIDNotNil() predicate.Car {
+	return predicate.Car(func(s *sql.Selector) {
+		s.Where(sql.NotNull(s.C(FieldAfterID)))
+	})
+}
+
 // ModelEQ applies the EQ predicate on the "model" field.
 func ModelEQ(v string) predicate.Car {
 	return predicate.Car(func(s *sql.Selector) {

entc/integration/customid/ent/car_create.go

@@ -24,12 +24,46 @@ type CarCreate struct {
 	hooks    []Hook
 }
 
+// SetBeforeID sets the before_id field.
+func (cc *CarCreate) SetBeforeID(f float64) *CarCreate {
+	cc.mutation.SetBeforeID(f)
+	return cc
+}
+
+// SetNillableBeforeID sets the before_id field if the given value is not nil.
+func (cc *CarCreate) SetNillableBeforeID(f *float64) *CarCreate {
+	if f != nil {
+		cc.SetBeforeID(*f)
+	}
+	return cc
+}
+
+// SetAfterID sets the after_id field.
+func (cc *CarCreate) SetAfterID(f float64) *CarCreate {
+	cc.mutation.SetAfterID(f)
+	return cc
+}
+
+// SetNillableAfterID sets the after_id field if the given value is not nil.
+func (cc *CarCreate) SetNillableAfterID(f *float64) *CarCreate {
+	if f != nil {
+		cc.SetAfterID(*f)
+	}
+	return cc
+}
+
 // SetModel sets the model field.
 func (cc *CarCreate) SetModel(s string) *CarCreate {
 	cc.mutation.SetModel(s)
 	return cc
 }
 
+// SetID sets the id field.
+func (cc *CarCreate) SetID(i int) *CarCreate {
+	cc.mutation.SetID(i)
+	return cc
+}
+
 // SetOwnerID sets the owner edge to Pet by id.
 func (cc *CarCreate) SetOwnerID(id string) *CarCreate {
 	cc.mutation.SetOwnerID(id)
@@ -51,9 +85,24 @@ func (cc *CarCreate) SetOwner(p *Pet) *CarCreate {
 
 // Save creates the Car in the database.
 func (cc *CarCreate) Save(ctx context.Context) (*Car, error) {
+	if v, ok := cc.mutation.BeforeID(); ok {
+		if err := car.BeforeIDValidator(v); err != nil {
+			return nil, fmt.Errorf("ent: validator failed for field \"before_id\": %w", err)
+		}
+	}
+	if v, ok := cc.mutation.AfterID(); ok {
+		if err := car.AfterIDValidator(v); err != nil {
+			return nil, fmt.Errorf("ent: validator failed for field \"after_id\": %w", err)
+		}
+	}
 	if _, ok := cc.mutation.Model(); !ok {
 		return nil, errors.New("ent: missing required field \"model\"")
 	}
+	if v, ok := cc.mutation.ID(); ok {
+		if err := car.IDValidator(v); err != nil {
+			return nil, fmt.Errorf("ent: validator failed for field \"id\": %w", err)
+		}
+	}
 	var (
 		err  error
 		node *Car
@@ -101,6 +150,26 @@ func (cc *CarCreate) sqlSave(ctx context.Context) (*Car, error) {
 			},
 		}
 	)
+	if id, ok := cc.mutation.ID(); ok {
+		c.ID = id
+		_spec.ID.Value = id
+	}
+	if value, ok := cc.mutation.BeforeID(); ok {
+		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldBeforeID,
+		})
+		c.BeforeID = value
+	}
+	if value, ok := cc.mutation.AfterID(); ok {
+		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldAfterID,
+		})
+		c.AfterID = value
+	}
 	if value, ok := cc.mutation.Model(); ok {
 		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
 			Type:   field.TypeString,
@@ -134,7 +203,9 @@ func (cc *CarCreate) sqlSave(ctx context.Context) (*Car, error) {
 		}
 		return nil, err
 	}
-	id := _spec.ID.Value.(int64)
-	c.ID = int(id)
+	if c.ID == 0 {
+		id := _spec.ID.Value.(int64)
+		c.ID = int(id)
+	}
 	return c, nil
 }

entc/integration/customid/ent/car_query.go

@@ -274,12 +274,12 @@ func (cq *CarQuery) WithOwner(opts ...func(*PetQuery)) *CarQuery {
 // Example:
 //
 //	var v []struct {
-//		Model string `json:"model,omitempty"`
+//		BeforeID float64 `json:"before_id,omitempty"`
 //		Count int `json:"count,omitempty"`
 //	}
 //
 //	client.Car.Query().
-//		GroupBy(car.FieldModel).
+//		GroupBy(car.FieldBeforeID).
 //		Aggregate(ent.Count()).
 //		Scan(ctx, &v)
 //
@@ -300,11 +300,11 @@ func (cq *CarQuery) GroupBy(field string, fields ...string) *CarGroupBy {
 // Example:
 //
 //	var v []struct {
-//		Model string `json:"model,omitempty"`
+//		BeforeID float64 `json:"before_id,omitempty"`
 //	}
 //
 //	client.Car.Query().
-//		Select(car.FieldModel).
+//		Select(car.FieldBeforeID).
 //		Scan(ctx, &v)
 //
 func (cq *CarQuery) Select(field string, fields ...string) *CarSelect {

entc/integration/customid/ent/car_update.go

@@ -32,6 +32,60 @@ func (cu *CarUpdate) Where(ps ...predicate.Car) *CarUpdate {
 	return cu
 }
 
+// SetBeforeID sets the before_id field.
+func (cu *CarUpdate) SetBeforeID(f float64) *CarUpdate {
+	cu.mutation.ResetBeforeID()
+	cu.mutation.SetBeforeID(f)
+	return cu
+}
+
+// SetNillableBeforeID sets the before_id field if the given value is not nil.
+func (cu *CarUpdate) SetNillableBeforeID(f *float64) *CarUpdate {
+	if f != nil {
+		cu.SetBeforeID(*f)
+	}
+	return cu
+}
+
+// AddBeforeID adds f to before_id.
+func (cu *CarUpdate) AddBeforeID(f float64) *CarUpdate {
+	cu.mutation.AddBeforeID(f)
+	return cu
+}
+
+// ClearBeforeID clears the value of before_id.
+func (cu *CarUpdate) ClearBeforeID() *CarUpdate {
+	cu.mutation.ClearBeforeID()
+	return cu
+}
+
+// SetAfterID sets the after_id field.
+func (cu *CarUpdate) SetAfterID(f float64) *CarUpdate {
+	cu.mutation.ResetAfterID()
+	cu.mutation.SetAfterID(f)
+	return cu
+}
+
+// SetNillableAfterID sets the after_id field if the given value is not nil.
+func (cu *CarUpdate) SetNillableAfterID(f *float64) *CarUpdate {
+	if f != nil {
+		cu.SetAfterID(*f)
+	}
+	return cu
+}
+
+// AddAfterID adds f to after_id.
+func (cu *CarUpdate) AddAfterID(f float64) *CarUpdate {
+	cu.mutation.AddAfterID(f)
+	return cu
+}
+
+// ClearAfterID clears the value of after_id.
+func (cu *CarUpdate) ClearAfterID() *CarUpdate {
+	cu.mutation.ClearAfterID()
+	return cu
+}
+
 // SetModel sets the model field.
 func (cu *CarUpdate) SetModel(s string) *CarUpdate {
 	cu.mutation.SetModel(s)
@@ -65,6 +119,16 @@ func (cu *CarUpdate) ClearOwner() *CarUpdate {
 
 // Save executes the query and returns the number of rows/vertices matched by this operation.
 func (cu *CarUpdate) Save(ctx context.Context) (int, error) {
+	if v, ok := cu.mutation.BeforeID(); ok {
+		if err := car.BeforeIDValidator(v); err != nil {
+			return 0, fmt.Errorf("ent: validator failed for field \"before_id\": %w", err)
+		}
+	}
+	if v, ok := cu.mutation.AfterID(); ok {
+		if err := car.AfterIDValidator(v); err != nil {
+			return 0, fmt.Errorf("ent: validator failed for field \"after_id\": %w", err)
+		}
+	}
 
 	var (
 		err      error
@@ -133,6 +197,46 @@ func (cu *CarUpdate) sqlSave(ctx context.Context) (n int, err error) {
 			}
 		}
 	}
+	if value, ok := cu.mutation.BeforeID(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldBeforeID,
+		})
+	}
+	if value, ok := cu.mutation.AddedBeforeID(); ok {
+		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldBeforeID,
+		})
+	}
+	if cu.mutation.BeforeIDCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Column: car.FieldBeforeID,
+		})
+	}
+	if value, ok := cu.mutation.AfterID(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldAfterID,
+		})
+	}
+	if value, ok := cu.mutation.AddedAfterID(); ok {
+		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldAfterID,
+		})
+	}
+	if cu.mutation.AfterIDCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Column: car.FieldAfterID,
+		})
+	}
 	if value, ok := cu.mutation.Model(); ok {
 		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
 			Type:   field.TypeString,
@@ -193,6 +297,60 @@ type CarUpdateOne struct {
 	mutation *CarMutation
 }
 
+// SetBeforeID sets the before_id field.
+func (cuo *CarUpdateOne) SetBeforeID(f float64) *CarUpdateOne {
+	cuo.mutation.ResetBeforeID()
+	cuo.mutation.SetBeforeID(f)
+	return cuo
+}
+
+// SetNillableBeforeID sets the before_id field if the given value is not nil.
+func (cuo *CarUpdateOne) SetNillableBeforeID(f *float64) *CarUpdateOne {
+	if f != nil {
+		cuo.SetBeforeID(*f)
+	}
+	return cuo
+}
+
+// AddBeforeID adds f to before_id.
+func (cuo *CarUpdateOne) AddBeforeID(f float64) *CarUpdateOne {
+	cuo.mutation.AddBeforeID(f)
+	return cuo
+}
+
+// ClearBeforeID clears the value of before_id.
+func (cuo *CarUpdateOne) ClearBeforeID() *CarUpdateOne {
+	cuo.mutation.ClearBeforeID()
+	return cuo
+}
+
+// SetAfterID sets the after_id field.
+func (cuo *CarUpdateOne) SetAfterID(f float64) *CarUpdateOne {
+	cuo.mutation.ResetAfterID()
+	cuo.mutation.SetAfterID(f)
+	return cuo
+}
+
+// SetNillableAfterID sets the after_id field if the given value is not nil.
+func (cuo *CarUpdateOne) SetNillableAfterID(f *float64) *CarUpdateOne {
+	if f != nil {
+		cuo.SetAfterID(*f)
+	}
+	return cuo
+}
+
+// AddAfterID adds f to after_id.
+func (cuo *CarUpdateOne) AddAfterID(f float64) *CarUpdateOne {
+	cuo.mutation.AddAfterID(f)
+	return cuo
+}
+
+// ClearAfterID clears the value of after_id.
+func (cuo *CarUpdateOne) ClearAfterID() *CarUpdateOne {
+	cuo.mutation.ClearAfterID()
+	return cuo
+}
+
 // SetModel sets the model field.
 func (cuo *CarUpdateOne) SetModel(s string) *CarUpdateOne {
 	cuo.mutation.SetModel(s)
@@ -226,6 +384,16 @@ func (cuo *CarUpdateOne) ClearOwner() *CarUpdateOne {
 
 // Save executes the query and returns the updated entity.
 func (cuo *CarUpdateOne) Save(ctx context.Context) (*Car, error) {
+	if v, ok := cuo.mutation.BeforeID(); ok {
+		if err := car.BeforeIDValidator(v); err != nil {
+			return nil, fmt.Errorf("ent: validator failed for field \"before_id\": %w", err)
+		}
+	}
+	if v, ok := cuo.mutation.AfterID(); ok {
+		if err := car.AfterIDValidator(v); err != nil {
+			return nil, fmt.Errorf("ent: validator failed for field \"after_id\": %w", err)
+		}
+	}
 
 	var (
 		err  error
@@ -292,6 +460,46 @@ func (cuo *CarUpdateOne) sqlSave(ctx context.Context) (c *Car, err error) {
 		return nil, fmt.Errorf("missing Car.ID for update")
 	}
 	_spec.Node.ID.Value = id
+	if value, ok := cuo.mutation.BeforeID(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldBeforeID,
+		})
+	}
+	if value, ok := cuo.mutation.AddedBeforeID(); ok {
+		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldBeforeID,
+		})
+	}
+	if cuo.mutation.BeforeIDCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Column: car.FieldBeforeID,
+		})
+	}
+	if value, ok := cuo.mutation.AfterID(); ok {
+		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldAfterID,
+		})
+	}
+	if value, ok := cuo.mutation.AddedAfterID(); ok {
+		_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Value:  value,
+			Column: car.FieldAfterID,
+		})
+	}
+	if cuo.mutation.AfterIDCleared() {
+		_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
+			Type:   field.TypeFloat64,
+			Column: car.FieldAfterID,
+		})
+	}
 	if value, ok := cuo.mutation.Model(); ok {
 		_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
 			Type:   field.TypeString,

entc/integration/customid/ent/migrate/schema.go

@@ -36,6 +36,8 @@ var (
 	// CarsColumns holds the columns for the "cars" table.
 	CarsColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "before_id", Type: field.TypeFloat64, Nullable: true},
+		{Name: "after_id", Type: field.TypeFloat64, Nullable: true},
 		{Name: "model", Type: field.TypeString},
 		{Name: "pet_cars", Type: field.TypeString, Nullable: true, Size: 25},
 	}
@@ -47,7 +49,7 @@ var (
 		ForeignKeys: []*schema.ForeignKey{
 			{
 				Symbol:  "cars_pets_cars",
-				Columns: []*schema.Column{CarsColumns[2]},
+				Columns: []*schema.Column{CarsColumns[4]},
 
 				RefColumns: []*schema.Column{PetsColumns[0]},
 				OnDelete:   schema.SetNull,

entc/integration/customid/ent/mutation.go

@@ -477,6 +477,10 @@ type CarMutation struct {
 	op            Op
 	typ           string
 	id            *int
+	before_id     *float64
+	addbefore_id  *float64
+	after_id      *float64
+	addafter_id   *float64
 	model         *string
 	clearedFields map[string]struct{}
 	owner         *string
@@ -555,6 +559,12 @@ func (m CarMutation) Tx() (*Tx, error) {
 	return tx, nil
 }
 
+// SetID sets the value of the id field. Note that, this
+// operation is accepted only on Car creation.
+func (m *CarMutation) SetID(id int) {
+	m.id = &id
+}
+
 // ID returns the id value in the mutation. Note that, the id
 // is available only if it was provided to the builder.
 func (m *CarMutation) ID() (id int, exists bool) {
@@ -564,6 +574,148 @@ func (m *CarMutation) ID() (id int, exists bool) {
 	return *m.id, true
 }
 
+// SetBeforeID sets the before_id field.
+func (m *CarMutation) SetBeforeID(f float64) {
+	m.before_id = &f
+	m.addbefore_id = nil
+}
+
+// BeforeID returns the before_id value in the mutation.
+func (m *CarMutation) BeforeID() (r float64, exists bool) {
+	v := m.before_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldBeforeID returns the old before_id value of the Car.
+// If the Car object wasn't provided to the builder, the object is fetched
+// from the database.
+// An error is returned if the mutation operation is not UpdateOne, or database query fails.
+func (m *CarMutation) OldBeforeID(ctx context.Context) (v float64, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, fmt.Errorf("OldBeforeID is allowed only on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, fmt.Errorf("OldBeforeID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldBeforeID: %w", err)
+	}
+	return oldValue.BeforeID, nil
+}
+
+// AddBeforeID adds f to before_id.
+func (m *CarMutation) AddBeforeID(f float64) {
+	if m.addbefore_id != nil {
+		*m.addbefore_id += f
+	} else {
+		m.addbefore_id = &f
+	}
+}
+
+// AddedBeforeID returns the value that was added to the before_id field in this mutation.
+func (m *CarMutation) AddedBeforeID() (r float64, exists bool) {
+	v := m.addbefore_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ClearBeforeID clears the value of before_id.
+func (m *CarMutation) ClearBeforeID() {
+	m.before_id = nil
+	m.addbefore_id = nil
+	m.clearedFields[car.FieldBeforeID] = struct{}{}
+}
+
+// BeforeIDCleared returns if the field before_id was cleared in this mutation.
+func (m *CarMutation) BeforeIDCleared() bool {
+	_, ok := m.clearedFields[car.FieldBeforeID]
+	return ok
+}
+
+// ResetBeforeID reset all changes of the "before_id" field.
+func (m *CarMutation) ResetBeforeID() {
+	m.before_id = nil
+	m.addbefore_id = nil
+	delete(m.clearedFields, car.FieldBeforeID)
+}
+
+// SetAfterID sets the after_id field.
+func (m *CarMutation) SetAfterID(f float64) {
+	m.after_id = &f
+	m.addafter_id = nil
+}
+
+// AfterID returns the after_id value in the mutation.
+func (m *CarMutation) AfterID() (r float64, exists bool) {
+	v := m.after_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// OldAfterID returns the old after_id value of the Car.
+// If the Car object wasn't provided to the builder, the object is fetched
+// from the database.
+// An error is returned if the mutation operation is not UpdateOne, or database query fails.
+func (m *CarMutation) OldAfterID(ctx context.Context) (v float64, err error) {
+	if !m.op.Is(OpUpdateOne) {
+		return v, fmt.Errorf("OldAfterID is allowed only on UpdateOne operations")
+	}
+	if m.id == nil || m.oldValue == nil {
+		return v, fmt.Errorf("OldAfterID requires an ID field in the mutation")
+	}
+	oldValue, err := m.oldValue(ctx)
+	if err != nil {
+		return v, fmt.Errorf("querying old value for OldAfterID: %w", err)
+	}
+	return oldValue.AfterID, nil
+}
+
+// AddAfterID adds f to after_id.
+func (m *CarMutation) AddAfterID(f float64) {
+	if m.addafter_id != nil {
+		*m.addafter_id += f
+	} else {
+		m.addafter_id = &f
+	}
+}
+
+// AddedAfterID returns the value that was added to the after_id field in this mutation.
+func (m *CarMutation) AddedAfterID() (r float64, exists bool) {
+	v := m.addafter_id
+	if v == nil {
+		return
+	}
+	return *v, true
+}
+
+// ClearAfterID clears the value of after_id.
+func (m *CarMutation) ClearAfterID() {
+	m.after_id = nil
+	m.addafter_id = nil
+	m.clearedFields[car.FieldAfterID] = struct{}{}
+}
+
+// AfterIDCleared returns if the field after_id was cleared in this mutation.
+func (m *CarMutation) AfterIDCleared() bool {
+	_, ok := m.clearedFields[car.FieldAfterID]
+	return ok
+}
+
+// ResetAfterID reset all changes of the "after_id" field.
+func (m *CarMutation) ResetAfterID() {
+	m.after_id = nil
+	m.addafter_id = nil
+	delete(m.clearedFields, car.FieldAfterID)
+}
+
 // SetModel sets the model field.
 func (m *CarMutation) SetModel(s string) {
 	m.model = &s
@@ -654,7 +806,13 @@ func (m *CarMutation) Type() string {
 // this mutation. Note that, in order to get all numeric
 // fields that were in/decremented, call AddedFields().
 func (m *CarMutation) Fields() []string {
-	fields := make([]string, 0, 1)
+	fields := make([]string, 0, 3)
+	if m.before_id != nil {
+		fields = append(fields, car.FieldBeforeID)
+	}
+	if m.after_id != nil {
+		fields = append(fields, car.FieldAfterID)
+	}
 	if m.model != nil {
 		fields = append(fields, car.FieldModel)
 	}
@@ -666,6 +824,10 @@ func (m *CarMutation) Fields() []string {
 // not set, or was not define in the schema.
 func (m *CarMutation) Field(name string) (ent.Value, bool) {
 	switch name {
+	case car.FieldBeforeID:
+		return m.BeforeID()
+	case car.FieldAfterID:
+		return m.AfterID()
 	case car.FieldModel:
 		return m.Model()
 	}
@@ -677,6 +839,10 @@ func (m *CarMutation) Field(name string) (ent.Value, bool) {
 // or the query to the database was failed.
 func (m *CarMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
 	switch name {
+	case car.FieldBeforeID:
+		return m.OldBeforeID(ctx)
+	case car.FieldAfterID:
+		return m.OldAfterID(ctx)
 	case car.FieldModel:
 		return m.OldModel(ctx)
 	}
@@ -688,6 +854,20 @@ func (m *CarMutation) OldField(ctx context.Context, name string) (ent.Value, err
 // type mismatch the field type.
 func (m *CarMutation) SetField(name string, value ent.Value) error {
 	switch name {
+	case car.FieldBeforeID:
+		v, ok := value.(float64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetBeforeID(v)
+		return nil
+	case car.FieldAfterID:
+		v, ok := value.(float64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.SetAfterID(v)
+		return nil
 	case car.FieldModel:
 		v, ok := value.(string)
 		if !ok {
@@ -702,13 +882,26 @@ func (m *CarMutation) SetField(name string, value ent.Value) error {
 // AddedFields returns all numeric fields that were incremented
 // or decremented during this mutation.
 func (m *CarMutation) AddedFields() []string {
-	return nil
+	var fields []string
+	if m.addbefore_id != nil {
+		fields = append(fields, car.FieldBeforeID)
+	}
+	if m.addafter_id != nil {
+		fields = append(fields, car.FieldAfterID)
+	}
+	return fields
 }
 
 // AddedField returns the numeric value that was in/decremented
 // from a field with the given name. The second value indicates
 // that this field was not set, or was not define in the schema.
 func (m *CarMutation) AddedField(name string) (ent.Value, bool) {
+	switch name {
+	case car.FieldBeforeID:
+		return m.AddedBeforeID()
+	case car.FieldAfterID:
+		return m.AddedAfterID()
+	}
 	return nil, false
 }
 
@@ -717,6 +910,20 @@ func (m *CarMutation) AddedField(name string) (ent.Value, bool) {
 // type mismatch the field type.
 func (m *CarMutation) AddField(name string, value ent.Value) error {
 	switch name {
+	case car.FieldBeforeID:
+		v, ok := value.(float64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddBeforeID(v)
+		return nil
+	case car.FieldAfterID:
+		v, ok := value.(float64)
+		if !ok {
+			return fmt.Errorf("unexpected type %T for field %s", value, name)
+		}
+		m.AddAfterID(v)
+		return nil
 	}
 	return fmt.Errorf("unknown Car numeric field %s", name)
 }
@@ -724,7 +931,14 @@ func (m *CarMutation) AddField(name string, value ent.Value) error {
 // ClearedFields returns all nullable fields that were cleared
 // during this mutation.
 func (m *CarMutation) ClearedFields() []string {
-	return nil
+	var fields []string
+	if m.FieldCleared(car.FieldBeforeID) {
+		fields = append(fields, car.FieldBeforeID)
+	}
+	if m.FieldCleared(car.FieldAfterID) {
+		fields = append(fields, car.FieldAfterID)
+	}
+	return fields
 }
 
 // FieldCleared returns a boolean indicates if this field was
@@ -737,6 +951,14 @@ func (m *CarMutation) FieldCleared(name string) bool {
 // ClearField clears the value for the given name. It returns an
 // error if the field is not defined in the schema.
 func (m *CarMutation) ClearField(name string) error {
+	switch name {
+	case car.FieldBeforeID:
+		m.ClearBeforeID()
+		return nil
+	case car.FieldAfterID:
+		m.ClearAfterID()
+		return nil
+	}
 	return fmt.Errorf("unknown Car nullable field %s", name)
 }
 
@@ -745,6 +967,12 @@ func (m *CarMutation) ClearField(name string) error {
 // defined in the schema.
 func (m *CarMutation) ResetField(name string) error {
 	switch name {
+	case car.FieldBeforeID:
+		m.ResetBeforeID()
+		return nil
+	case car.FieldAfterID:
+		m.ResetAfterID()
+		return nil
 	case car.FieldModel:
 		m.ResetModel()
 		return nil

entc/integration/customid/ent/runtime.go

@@ -8,6 +8,7 @@ package ent
 
 import (
 	"github.com/facebookincubator/ent/entc/integration/customid/ent/blob"
+	"github.com/facebookincubator/ent/entc/integration/customid/ent/car"
 	"github.com/facebookincubator/ent/entc/integration/customid/ent/pet"
 	"github.com/facebookincubator/ent/entc/integration/customid/ent/schema"
 	"github.com/google/uuid"
@@ -27,6 +28,22 @@ func init() {
 	blobDescID := blobFields[0].Descriptor()
 	// blob.DefaultID holds the default value on creation for the id field.
 	blob.DefaultID = blobDescID.Default.(func() uuid.UUID)
+	carMixin := schema.Car{}.Mixin()
+	carMixinFields0 := carMixin[0].Fields()
+	carFields := schema.Car{}.Fields()
+	_ = carFields
+	// carDescBeforeID is the schema descriptor for before_id field.
+	carDescBeforeID := carMixinFields0[0].Descriptor()
+	// car.BeforeIDValidator is a validator for the "before_id" field. It is called by the builders before save.
+	car.BeforeIDValidator = carDescBeforeID.Validators[0].(func(float64) error)
+	// carDescAfterID is the schema descriptor for after_id field.
+	carDescAfterID := carMixinFields0[2].Descriptor()
+	// car.AfterIDValidator is a validator for the "after_id" field. It is called by the builders before save.
+	car.AfterIDValidator = carDescAfterID.Validators[0].(func(float64) error)
+	// carDescID is the schema descriptor for id field.
+	carDescID := carMixinFields0[1].Descriptor()
+	// car.IDValidator is a validator for the "id" field. It is called by the builders before save.
+	car.IDValidator = carDescID.Validators[0].(func(int) error)
 	petFields := schema.Pet{}.Fields()
 	_ = petFields
 	// petDescID is the schema descriptor for id field.

entc/integration/customid/ent/schema/car.go

@@ -8,13 +8,39 @@ import (
 	"github.com/facebookincubator/ent"
 	"github.com/facebookincubator/ent/schema/edge"
 	"github.com/facebookincubator/ent/schema/field"
+	"github.com/facebookincubator/ent/schema/mixin"
 )
 
+type IDMixin struct {
+	mixin.Schema
+}
+
+func (IDMixin) Fields() []ent.Field {
+	return []ent.Field{
+		field.Float("before_id").
+			Optional().
+			Positive(),
+		field.Int("id").
+			Positive().
+			Immutable(),
+		field.Float("after_id").
+			Optional().
+			Negative(),
+	}
+}
+
 // Car holds the schema definition for the Car entity.
 type Car struct {
 	ent.Schema
 }
 
+// Mixin of the Car.
+func (Car) Mixin() []ent.Mixin {
+	return []ent.Mixin{
+		IDMixin{},
+	}
+}
+
 // Fields of the Car.
 func (Car) Fields() []ent.Field {
 	return []ent.Field{