examples: regenerate assets

examples/traversal/ent/client.go

@@ -176,16 +176,11 @@ func (c *GroupClient) GetX(ctx context.Context, id int) *Group {
 func (c *GroupClient) QueryUsers(gr *Group) *UserQuery {
 	query := &UserQuery{config: c.config}
 	id := gr.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = group.Table
-	step.From.Column = group.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = false
-	step.Edge.Table = group.UsersTable
-	step.Edge.Columns = append(step.Edge.Columns, group.UsersPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(group.Table, group.FieldID, id),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2M, false, group.UsersTable, group.UsersPrimaryKey...),
+	)
 	query.sql = sql.Neighbors(gr.driver.Dialect(), step)
 
 	return query
@@ -195,16 +190,11 @@ func (c *GroupClient) QueryUsers(gr *Group) *UserQuery {
 func (c *GroupClient) QueryAdmin(gr *Group) *UserQuery {
 	query := &UserQuery{config: c.config}
 	id := gr.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = group.Table
-	step.From.Column = group.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2O
-	step.Edge.Inverse = false
-	step.Edge.Table = group.AdminTable
-	step.Edge.Columns = append(step.Edge.Columns, group.AdminColumn)
+	step := sql.NewStep(
+		sql.From(group.Table, group.FieldID, id),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2O, false, group.AdminTable, group.AdminColumn),
+	)
 	query.sql = sql.Neighbors(gr.driver.Dialect(), step)
 
 	return query
@@ -278,16 +268,11 @@ func (c *PetClient) GetX(ctx context.Context, id int) *Pet {
 func (c *PetClient) QueryFriends(pe *Pet) *PetQuery {
 	query := &PetQuery{config: c.config}
 	id := pe.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = pet.Table
-	step.From.Column = pet.FieldID
-	step.To.Table = pet.Table
-	step.To.Column = pet.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = false
-	step.Edge.Table = pet.FriendsTable
-	step.Edge.Columns = append(step.Edge.Columns, pet.FriendsPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(pet.Table, pet.FieldID, id),
+		sql.To(pet.Table, pet.FieldID),
+		sql.Edge(sql.M2M, false, pet.FriendsTable, pet.FriendsPrimaryKey...),
+	)
 	query.sql = sql.Neighbors(pe.driver.Dialect(), step)
 
 	return query
@@ -297,16 +282,11 @@ func (c *PetClient) QueryFriends(pe *Pet) *PetQuery {
 func (c *PetClient) QueryOwner(pe *Pet) *UserQuery {
 	query := &UserQuery{config: c.config}
 	id := pe.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = pet.Table
-	step.From.Column = pet.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2O
-	step.Edge.Inverse = true
-	step.Edge.Table = pet.OwnerTable
-	step.Edge.Columns = append(step.Edge.Columns, pet.OwnerColumn)
+	step := sql.NewStep(
+		sql.From(pet.Table, pet.FieldID, id),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2O, true, pet.OwnerTable, pet.OwnerColumn),
+	)
 	query.sql = sql.Neighbors(pe.driver.Dialect(), step)
 
 	return query
@@ -380,16 +360,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User {
 func (c *UserClient) QueryPets(u *User) *PetQuery {
 	query := &PetQuery{config: c.config}
 	id := u.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = pet.Table
-	step.To.Column = pet.FieldID
-	step.Edge.Rel = sql.O2M
-	step.Edge.Inverse = false
-	step.Edge.Table = user.PetsTable
-	step.Edge.Columns = append(step.Edge.Columns, user.PetsColumn)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, id),
+		sql.To(pet.Table, pet.FieldID),
+		sql.Edge(sql.O2M, false, user.PetsTable, user.PetsColumn),
+	)
 	query.sql = sql.Neighbors(u.driver.Dialect(), step)
 
 	return query
@@ -399,16 +374,11 @@ func (c *UserClient) QueryPets(u *User) *PetQuery {
 func (c *UserClient) QueryFriends(u *User) *UserQuery {
 	query := &UserQuery{config: c.config}
 	id := u.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = false
-	step.Edge.Table = user.FriendsTable
-	step.Edge.Columns = append(step.Edge.Columns, user.FriendsPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, id),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2M, false, user.FriendsTable, user.FriendsPrimaryKey...),
+	)
 	query.sql = sql.Neighbors(u.driver.Dialect(), step)
 
 	return query
@@ -418,16 +388,11 @@ func (c *UserClient) QueryFriends(u *User) *UserQuery {
 func (c *UserClient) QueryGroups(u *User) *GroupQuery {
 	query := &GroupQuery{config: c.config}
 	id := u.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = group.Table
-	step.To.Column = group.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = true
-	step.Edge.Table = user.GroupsTable
-	step.Edge.Columns = append(step.Edge.Columns, user.GroupsPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, id),
+		sql.To(group.Table, group.FieldID),
+		sql.Edge(sql.M2M, true, user.GroupsTable, user.GroupsPrimaryKey...),
+	)
 	query.sql = sql.Neighbors(u.driver.Dialect(), step)
 
 	return query
@@ -437,16 +402,11 @@ func (c *UserClient) QueryGroups(u *User) *GroupQuery {
 func (c *UserClient) QueryManage(u *User) *GroupQuery {
 	query := &GroupQuery{config: c.config}
 	id := u.ID
-	step := &sql.Step{}
-	step.From.V = id
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = group.Table
-	step.To.Column = group.FieldID
-	step.Edge.Rel = sql.O2M
-	step.Edge.Inverse = true
-	step.Edge.Table = user.ManageTable
-	step.Edge.Columns = append(step.Edge.Columns, user.ManageColumn)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, id),
+		sql.To(group.Table, group.FieldID),
+		sql.Edge(sql.O2M, true, user.ManageTable, user.ManageColumn),
+	)
 	query.sql = sql.Neighbors(u.driver.Dialect(), step)
 
 	return query

examples/traversal/ent/group/where.go

@@ -262,15 +262,12 @@ func NameContainsFold(v string) predicate.Group {
 func HasUsers() predicate.Group {
 	return predicate.Group(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			builder := sql.Dialect(s.Dialect())
-			s.Where(
-				sql.In(
-					t1.C(FieldID),
-					builder.Select(UsersPrimaryKey[0]).
-						From(builder.Table(UsersTable)),
-				),
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(UsersTable, FieldID),
+				sql.Edge(sql.M2M, false, UsersTable, UsersPrimaryKey...),
 			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -279,20 +276,16 @@ func HasUsers() predicate.Group {
 func HasUsersWith(preds ...predicate.User) predicate.Group {
 	return predicate.Group(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Table(UsersInverseTable)
-			t3 := builder.Table(UsersTable)
-			t4 := builder.Select(t3.C(UsersPrimaryKey[0])).
-				From(t3).
-				Join(t2).
-				On(t3.C(UsersPrimaryKey[1]), t2.C(FieldID))
-			t5 := builder.Select().From(t2)
-			for _, p := range preds {
-				p(t5)
-			}
-			t4.FromSelect(t5)
-			s.Where(sql.In(t1.C(FieldID), t4))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(UsersInverseTable, FieldID),
+				sql.Edge(sql.M2M, false, UsersTable, UsersPrimaryKey...),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }
@@ -301,8 +294,12 @@ func HasUsersWith(preds ...predicate.User) predicate.Group {
 func HasAdmin() predicate.Group {
 	return predicate.Group(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			s.Where(sql.NotNull(t1.C(AdminColumn)))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(AdminTable, FieldID),
+				sql.Edge(sql.M2O, false, AdminTable, AdminColumn),
+			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -311,13 +308,16 @@ func HasAdmin() predicate.Group {
 func HasAdminWith(preds ...predicate.User) predicate.Group {
 	return predicate.Group(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Select(FieldID).From(builder.Table(AdminInverseTable))
-			for _, p := range preds {
-				p(t2)
-			}
-			s.Where(sql.In(t1.C(AdminColumn), t2))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(AdminInverseTable, FieldID),
+				sql.Edge(sql.M2O, false, AdminTable, AdminColumn),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }

examples/traversal/ent/group_query.go

@@ -57,16 +57,11 @@ func (gq *GroupQuery) Order(o ...Order) *GroupQuery {
 // QueryUsers chains the current query on the users edge.
 func (gq *GroupQuery) QueryUsers() *UserQuery {
 	query := &UserQuery{config: gq.config}
-	step := &sql.Step{}
-	step.From.V = gq.sqlQuery()
-	step.From.Table = group.Table
-	step.From.Column = group.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = false
-	step.Edge.Table = group.UsersTable
-	step.Edge.Columns = append(step.Edge.Columns, group.UsersPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(group.Table, group.FieldID, gq.sqlQuery()),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2M, false, group.UsersTable, group.UsersPrimaryKey...),
+	)
 	query.sql = sql.SetNeighbors(gq.driver.Dialect(), step)
 	return query
 }
@@ -74,16 +69,11 @@ func (gq *GroupQuery) QueryUsers() *UserQuery {
 // QueryAdmin chains the current query on the admin edge.
 func (gq *GroupQuery) QueryAdmin() *UserQuery {
 	query := &UserQuery{config: gq.config}
-	step := &sql.Step{}
-	step.From.V = gq.sqlQuery()
-	step.From.Table = group.Table
-	step.From.Column = group.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2O
-	step.Edge.Inverse = false
-	step.Edge.Table = group.AdminTable
-	step.Edge.Columns = append(step.Edge.Columns, group.AdminColumn)
+	step := sql.NewStep(
+		sql.From(group.Table, group.FieldID, gq.sqlQuery()),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2O, false, group.AdminTable, group.AdminColumn),
+	)
 	query.sql = sql.SetNeighbors(gq.driver.Dialect(), step)
 	return query
 }

examples/traversal/ent/pet/where.go

@@ -262,15 +262,12 @@ func NameContainsFold(v string) predicate.Pet {
 func HasFriends() predicate.Pet {
 	return predicate.Pet(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			builder := sql.Dialect(s.Dialect())
-			s.Where(
-				sql.In(
-					t1.C(FieldID),
-					builder.Select(FriendsPrimaryKey[0]).
-						From(builder.Table(FriendsTable)),
-				),
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(FriendsTable, FieldID),
+				sql.Edge(sql.M2M, false, FriendsTable, FriendsPrimaryKey...),
 			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -279,20 +276,16 @@ func HasFriends() predicate.Pet {
 func HasFriendsWith(preds ...predicate.Pet) predicate.Pet {
 	return predicate.Pet(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Table(Table)
-			t3 := builder.Table(FriendsTable)
-			t4 := builder.Select(t3.C(FriendsPrimaryKey[0])).
-				From(t3).
-				Join(t2).
-				On(t3.C(FriendsPrimaryKey[1]), t2.C(FieldID))
-			t5 := builder.Select().From(t2)
-			for _, p := range preds {
-				p(t5)
-			}
-			t4.FromSelect(t5)
-			s.Where(sql.In(t1.C(FieldID), t4))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(Table, FieldID),
+				sql.Edge(sql.M2M, false, FriendsTable, FriendsPrimaryKey...),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }
@@ -301,8 +294,12 @@ func HasFriendsWith(preds ...predicate.Pet) predicate.Pet {
 func HasOwner() predicate.Pet {
 	return predicate.Pet(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			s.Where(sql.NotNull(t1.C(OwnerColumn)))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(OwnerTable, FieldID),
+				sql.Edge(sql.M2O, true, OwnerTable, OwnerColumn),
+			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -311,13 +308,16 @@ func HasOwner() predicate.Pet {
 func HasOwnerWith(preds ...predicate.User) predicate.Pet {
 	return predicate.Pet(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Select(FieldID).From(builder.Table(OwnerInverseTable))
-			for _, p := range preds {
-				p(t2)
-			}
-			s.Where(sql.In(t1.C(OwnerColumn), t2))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(OwnerInverseTable, FieldID),
+				sql.Edge(sql.M2O, true, OwnerTable, OwnerColumn),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }

examples/traversal/ent/pet_query.go

@@ -57,16 +57,11 @@ func (pq *PetQuery) Order(o ...Order) *PetQuery {
 // QueryFriends chains the current query on the friends edge.
 func (pq *PetQuery) QueryFriends() *PetQuery {
 	query := &PetQuery{config: pq.config}
-	step := &sql.Step{}
-	step.From.V = pq.sqlQuery()
-	step.From.Table = pet.Table
-	step.From.Column = pet.FieldID
-	step.To.Table = pet.Table
-	step.To.Column = pet.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = false
-	step.Edge.Table = pet.FriendsTable
-	step.Edge.Columns = append(step.Edge.Columns, pet.FriendsPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(pet.Table, pet.FieldID, pq.sqlQuery()),
+		sql.To(pet.Table, pet.FieldID),
+		sql.Edge(sql.M2M, false, pet.FriendsTable, pet.FriendsPrimaryKey...),
+	)
 	query.sql = sql.SetNeighbors(pq.driver.Dialect(), step)
 	return query
 }
@@ -74,16 +69,11 @@ func (pq *PetQuery) QueryFriends() *PetQuery {
 // QueryOwner chains the current query on the owner edge.
 func (pq *PetQuery) QueryOwner() *UserQuery {
 	query := &UserQuery{config: pq.config}
-	step := &sql.Step{}
-	step.From.V = pq.sqlQuery()
-	step.From.Table = pet.Table
-	step.From.Column = pet.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2O
-	step.Edge.Inverse = true
-	step.Edge.Table = pet.OwnerTable
-	step.Edge.Columns = append(step.Edge.Columns, pet.OwnerColumn)
+	step := sql.NewStep(
+		sql.From(pet.Table, pet.FieldID, pq.sqlQuery()),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2O, true, pet.OwnerTable, pet.OwnerColumn),
+	)
 	query.sql = sql.SetNeighbors(pq.driver.Dialect(), step)
 	return query
 }

examples/traversal/ent/user/where.go

@@ -363,16 +363,12 @@ func NameContainsFold(v string) predicate.User {
 func HasPets() predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			builder := sql.Dialect(s.Dialect())
-			s.Where(
-				sql.In(
-					t1.C(FieldID),
-					builder.Select(PetsColumn).
-						From(builder.Table(PetsTable)).
-						Where(sql.NotNull(PetsColumn)),
-				),
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(PetsTable, FieldID),
+				sql.Edge(sql.O2M, false, PetsTable, PetsColumn),
 			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -381,13 +377,16 @@ func HasPets() predicate.User {
 func HasPetsWith(preds ...predicate.Pet) predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Select(PetsColumn).From(builder.Table(PetsTable))
-			for _, p := range preds {
-				p(t2)
-			}
-			s.Where(sql.In(t1.C(FieldID), t2))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(PetsInverseTable, FieldID),
+				sql.Edge(sql.O2M, false, PetsTable, PetsColumn),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }
@@ -396,15 +395,12 @@ func HasPetsWith(preds ...predicate.Pet) predicate.User {
 func HasFriends() predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			builder := sql.Dialect(s.Dialect())
-			s.Where(
-				sql.In(
-					t1.C(FieldID),
-					builder.Select(FriendsPrimaryKey[0]).
-						From(builder.Table(FriendsTable)),
-				),
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(FriendsTable, FieldID),
+				sql.Edge(sql.M2M, false, FriendsTable, FriendsPrimaryKey...),
 			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -413,20 +409,16 @@ func HasFriends() predicate.User {
 func HasFriendsWith(preds ...predicate.User) predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Table(Table)
-			t3 := builder.Table(FriendsTable)
-			t4 := builder.Select(t3.C(FriendsPrimaryKey[0])).
-				From(t3).
-				Join(t2).
-				On(t3.C(FriendsPrimaryKey[1]), t2.C(FieldID))
-			t5 := builder.Select().From(t2)
-			for _, p := range preds {
-				p(t5)
-			}
-			t4.FromSelect(t5)
-			s.Where(sql.In(t1.C(FieldID), t4))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(Table, FieldID),
+				sql.Edge(sql.M2M, false, FriendsTable, FriendsPrimaryKey...),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }
@@ -435,15 +427,12 @@ func HasFriendsWith(preds ...predicate.User) predicate.User {
 func HasGroups() predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			builder := sql.Dialect(s.Dialect())
-			s.Where(
-				sql.In(
-					t1.C(FieldID),
-					builder.Select(GroupsPrimaryKey[1]).
-						From(builder.Table(GroupsTable)),
-				),
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(GroupsTable, FieldID),
+				sql.Edge(sql.M2M, true, GroupsTable, GroupsPrimaryKey...),
 			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -452,20 +441,16 @@ func HasGroups() predicate.User {
 func HasGroupsWith(preds ...predicate.Group) predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Table(GroupsInverseTable)
-			t3 := builder.Table(GroupsTable)
-			t4 := builder.Select(t3.C(GroupsPrimaryKey[1])).
-				From(t3).
-				Join(t2).
-				On(t3.C(GroupsPrimaryKey[0]), t2.C(FieldID))
-			t5 := builder.Select().From(t2)
-			for _, p := range preds {
-				p(t5)
-			}
-			t4.FromSelect(t5)
-			s.Where(sql.In(t1.C(FieldID), t4))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(GroupsInverseTable, FieldID),
+				sql.Edge(sql.M2M, true, GroupsTable, GroupsPrimaryKey...),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }
@@ -474,16 +459,12 @@ func HasGroupsWith(preds ...predicate.Group) predicate.User {
 func HasManage() predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			t1 := s.Table()
-			builder := sql.Dialect(s.Dialect())
-			s.Where(
-				sql.In(
-					t1.C(FieldID),
-					builder.Select(ManageColumn).
-						From(builder.Table(ManageTable)).
-						Where(sql.NotNull(ManageColumn)),
-				),
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(ManageTable, FieldID),
+				sql.Edge(sql.O2M, true, ManageTable, ManageColumn),
 			)
+			sql.HasNeighbors(s, step)
 		},
 	)
 }
@@ -492,13 +473,16 @@ func HasManage() predicate.User {
 func HasManageWith(preds ...predicate.Group) predicate.User {
 	return predicate.User(
 		func(s *sql.Selector) {
-			builder := sql.Dialect(s.Dialect())
-			t1 := s.Table()
-			t2 := builder.Select(ManageColumn).From(builder.Table(ManageTable))
-			for _, p := range preds {
-				p(t2)
-			}
-			s.Where(sql.In(t1.C(FieldID), t2))
+			step := sql.NewStep(
+				sql.From(Table, FieldID),
+				sql.To(ManageInverseTable, FieldID),
+				sql.Edge(sql.O2M, true, ManageTable, ManageColumn),
+			)
+			sql.HasNeighborsWith(s, step, func(s *sql.Selector) {
+				for _, p := range preds {
+					p(s)
+				}
+			})
 		},
 	)
 }

examples/traversal/ent/user_query.go

@@ -58,16 +58,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery {
 // QueryPets chains the current query on the pets edge.
 func (uq *UserQuery) QueryPets() *PetQuery {
 	query := &PetQuery{config: uq.config}
-	step := &sql.Step{}
-	step.From.V = uq.sqlQuery()
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = pet.Table
-	step.To.Column = pet.FieldID
-	step.Edge.Rel = sql.O2M
-	step.Edge.Inverse = false
-	step.Edge.Table = user.PetsTable
-	step.Edge.Columns = append(step.Edge.Columns, user.PetsColumn)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, uq.sqlQuery()),
+		sql.To(pet.Table, pet.FieldID),
+		sql.Edge(sql.O2M, false, user.PetsTable, user.PetsColumn),
+	)
 	query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
 	return query
 }
@@ -75,16 +70,11 @@ func (uq *UserQuery) QueryPets() *PetQuery {
 // QueryFriends chains the current query on the friends edge.
 func (uq *UserQuery) QueryFriends() *UserQuery {
 	query := &UserQuery{config: uq.config}
-	step := &sql.Step{}
-	step.From.V = uq.sqlQuery()
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = user.Table
-	step.To.Column = user.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = false
-	step.Edge.Table = user.FriendsTable
-	step.Edge.Columns = append(step.Edge.Columns, user.FriendsPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, uq.sqlQuery()),
+		sql.To(user.Table, user.FieldID),
+		sql.Edge(sql.M2M, false, user.FriendsTable, user.FriendsPrimaryKey...),
+	)
 	query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
 	return query
 }
@@ -92,16 +82,11 @@ func (uq *UserQuery) QueryFriends() *UserQuery {
 // QueryGroups chains the current query on the groups edge.
 func (uq *UserQuery) QueryGroups() *GroupQuery {
 	query := &GroupQuery{config: uq.config}
-	step := &sql.Step{}
-	step.From.V = uq.sqlQuery()
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = group.Table
-	step.To.Column = group.FieldID
-	step.Edge.Rel = sql.M2M
-	step.Edge.Inverse = true
-	step.Edge.Table = user.GroupsTable
-	step.Edge.Columns = append(step.Edge.Columns, user.GroupsPrimaryKey...)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, uq.sqlQuery()),
+		sql.To(group.Table, group.FieldID),
+		sql.Edge(sql.M2M, true, user.GroupsTable, user.GroupsPrimaryKey...),
+	)
 	query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
 	return query
 }
@@ -109,16 +94,11 @@ func (uq *UserQuery) QueryGroups() *GroupQuery {
 // QueryManage chains the current query on the manage edge.
 func (uq *UserQuery) QueryManage() *GroupQuery {
 	query := &GroupQuery{config: uq.config}
-	step := &sql.Step{}
-	step.From.V = uq.sqlQuery()
-	step.From.Table = user.Table
-	step.From.Column = user.FieldID
-	step.To.Table = group.Table
-	step.To.Column = group.FieldID
-	step.Edge.Rel = sql.O2M
-	step.Edge.Inverse = true
-	step.Edge.Table = user.ManageTable
-	step.Edge.Columns = append(step.Edge.Columns, user.ManageColumn)
+	step := sql.NewStep(
+		sql.From(user.Table, user.FieldID, uq.sqlQuery()),
+		sql.To(group.Table, group.FieldID),
+		sql.Edge(sql.O2M, true, user.ManageTable, user.ManageColumn),
+	)
 	query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
 	return query
 }