diff --git a/examples/edgeindex/ent/city/where.go b/examples/edgeindex/ent/city/where.go index 2fb00f007..6ceed7beb 100644 --- a/examples/edgeindex/ent/city/where.go +++ b/examples/edgeindex/ent/city/where.go @@ -262,16 +262,12 @@ func NameContainsFold(v string) predicate.City { func HasStreets() predicate.City { return predicate.City( func(s *sql.Selector) { - t1 := s.Table() - builder := sql.Dialect(s.Dialect()) - s.Where( - sql.In( - t1.C(FieldID), - builder.Select(StreetsColumn). - From(builder.Table(StreetsTable)). - Where(sql.NotNull(StreetsColumn)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(StreetsTable, FieldID), + sql.Edge(sql.O2M, false, StreetsTable, StreetsColumn), ) + sql.HasNeighbors(s, step) }, ) } @@ -280,13 +276,16 @@ func HasStreets() predicate.City { func HasStreetsWith(preds ...predicate.Street) predicate.City { return predicate.City( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(StreetsColumn).From(builder.Table(StreetsTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(FieldID), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(StreetsInverseTable, FieldID), + sql.Edge(sql.O2M, false, StreetsTable, StreetsColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/edgeindex/ent/city_query.go b/examples/edgeindex/ent/city_query.go index 24e78e4e1..b64631e1d 100644 --- a/examples/edgeindex/ent/city_query.go +++ b/examples/edgeindex/ent/city_query.go @@ -57,16 +57,11 @@ func (cq *CityQuery) Order(o ...Order) *CityQuery { // QueryStreets chains the current query on the streets edge. func (cq *CityQuery) QueryStreets() *StreetQuery { query := &StreetQuery{config: cq.config} - step := &sql.Step{} - step.From.V = cq.sqlQuery() - step.From.Table = city.Table - step.From.Column = city.FieldID - step.To.Table = street.Table - step.To.Column = street.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = city.StreetsTable - step.Edge.Columns = append(step.Edge.Columns, city.StreetsColumn) + step := sql.NewStep( + sql.From(city.Table, city.FieldID, cq.sqlQuery()), + sql.To(street.Table, street.FieldID), + sql.Edge(sql.O2M, false, city.StreetsTable, city.StreetsColumn), + ) query.sql = sql.SetNeighbors(cq.driver.Dialect(), step) return query } diff --git a/examples/edgeindex/ent/client.go b/examples/edgeindex/ent/client.go index 1bdfd7d2f..190686582 100644 --- a/examples/edgeindex/ent/client.go +++ b/examples/edgeindex/ent/client.go @@ -170,16 +170,11 @@ func (c *CityClient) GetX(ctx context.Context, id int) *City { func (c *CityClient) QueryStreets(ci *City) *StreetQuery { query := &StreetQuery{config: c.config} id := ci.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = city.Table - step.From.Column = city.FieldID - step.To.Table = street.Table - step.To.Column = street.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = city.StreetsTable - step.Edge.Columns = append(step.Edge.Columns, city.StreetsColumn) + step := sql.NewStep( + sql.From(city.Table, city.FieldID, id), + sql.To(street.Table, street.FieldID), + sql.Edge(sql.O2M, false, city.StreetsTable, city.StreetsColumn), + ) query.sql = sql.Neighbors(ci.driver.Dialect(), step) return query @@ -253,16 +248,11 @@ func (c *StreetClient) GetX(ctx context.Context, id int) *Street { func (c *StreetClient) QueryCity(s *Street) *CityQuery { query := &CityQuery{config: c.config} id := s.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = street.Table - step.From.Column = street.FieldID - step.To.Table = city.Table - step.To.Column = city.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = street.CityTable - step.Edge.Columns = append(step.Edge.Columns, street.CityColumn) + step := sql.NewStep( + sql.From(street.Table, street.FieldID, id), + sql.To(city.Table, city.FieldID), + sql.Edge(sql.M2O, true, street.CityTable, street.CityColumn), + ) query.sql = sql.Neighbors(s.driver.Dialect(), step) return query diff --git a/examples/edgeindex/ent/street/where.go b/examples/edgeindex/ent/street/where.go index f244794ad..e1526c00d 100644 --- a/examples/edgeindex/ent/street/where.go +++ b/examples/edgeindex/ent/street/where.go @@ -262,8 +262,12 @@ func NameContainsFold(v string) predicate.Street { func HasCity() predicate.Street { return predicate.Street( func(s *sql.Selector) { - t1 := s.Table() - s.Where(sql.NotNull(t1.C(CityColumn))) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(CityTable, FieldID), + sql.Edge(sql.M2O, true, CityTable, CityColumn), + ) + sql.HasNeighbors(s, step) }, ) } @@ -272,13 +276,16 @@ func HasCity() predicate.Street { func HasCityWith(preds ...predicate.City) predicate.Street { return predicate.Street( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(FieldID).From(builder.Table(CityInverseTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(CityColumn), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(CityInverseTable, FieldID), + sql.Edge(sql.M2O, true, CityTable, CityColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/edgeindex/ent/street_query.go b/examples/edgeindex/ent/street_query.go index ad562d0ad..2edb65730 100644 --- a/examples/edgeindex/ent/street_query.go +++ b/examples/edgeindex/ent/street_query.go @@ -57,16 +57,11 @@ func (sq *StreetQuery) Order(o ...Order) *StreetQuery { // QueryCity chains the current query on the city edge. func (sq *StreetQuery) QueryCity() *CityQuery { query := &CityQuery{config: sq.config} - step := &sql.Step{} - step.From.V = sq.sqlQuery() - step.From.Table = street.Table - step.From.Column = street.FieldID - step.To.Table = city.Table - step.To.Column = city.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = street.CityTable - step.Edge.Columns = append(step.Edge.Columns, street.CityColumn) + step := sql.NewStep( + sql.From(street.Table, street.FieldID, sq.sqlQuery()), + sql.To(city.Table, city.FieldID), + sql.Edge(sql.M2O, true, street.CityTable, street.CityColumn), + ) query.sql = sql.SetNeighbors(sq.driver.Dialect(), step) return query } diff --git a/examples/m2m2types/ent/client.go b/examples/m2m2types/ent/client.go index b00ee8263..b801207cf 100644 --- a/examples/m2m2types/ent/client.go +++ b/examples/m2m2types/ent/client.go @@ -170,16 +170,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 @@ -253,16 +248,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { 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 diff --git a/examples/m2m2types/ent/group/where.go b/examples/m2m2types/ent/group/where.go index 4ada30074..219929110 100644 --- a/examples/m2m2types/ent/group/where.go +++ b/examples/m2m2types/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) + } + }) }, ) } diff --git a/examples/m2m2types/ent/group_query.go b/examples/m2m2types/ent/group_query.go index c4773b57b..95b49e970 100644 --- a/examples/m2m2types/ent/group_query.go +++ b/examples/m2m2types/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 } diff --git a/examples/m2m2types/ent/user/where.go b/examples/m2m2types/ent/user/where.go index 95d83e41e..a78d69714 100644 --- a/examples/m2m2types/ent/user/where.go +++ b/examples/m2m2types/ent/user/where.go @@ -363,15 +363,12 @@ func NameContainsFold(v string) 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) }, ) } @@ -380,20 +377,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) + } + }) }, ) } diff --git a/examples/m2m2types/ent/user_query.go b/examples/m2m2types/ent/user_query.go index ed1408e4e..5c7f3a882 100644 --- a/examples/m2m2types/ent/user_query.go +++ b/examples/m2m2types/ent/user_query.go @@ -57,16 +57,11 @@ func (uq *UserQuery) Order(o ...Order) *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 } diff --git a/examples/m2mbidi/ent/client.go b/examples/m2mbidi/ent/client.go index 088c35ef0..43d8087ae 100644 --- a/examples/m2mbidi/ent/client.go +++ b/examples/m2mbidi/ent/client.go @@ -164,16 +164,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { 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 diff --git a/examples/m2mbidi/ent/user/where.go b/examples/m2mbidi/ent/user/where.go index b03843045..d0b85817e 100644 --- a/examples/m2mbidi/ent/user/where.go +++ b/examples/m2mbidi/ent/user/where.go @@ -363,15 +363,12 @@ func NameContainsFold(v string) 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) }, ) } @@ -380,20 +377,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) + } + }) }, ) } diff --git a/examples/m2mbidi/ent/user_query.go b/examples/m2mbidi/ent/user_query.go index 8cb04a53d..03500efc9 100644 --- a/examples/m2mbidi/ent/user_query.go +++ b/examples/m2mbidi/ent/user_query.go @@ -56,16 +56,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // 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 } diff --git a/examples/m2mrecur/ent/client.go b/examples/m2mrecur/ent/client.go index a6868dbc5..d206848e1 100644 --- a/examples/m2mrecur/ent/client.go +++ b/examples/m2mrecur/ent/client.go @@ -164,16 +164,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryFollowers(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 = true - step.Edge.Table = user.FollowersTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowersPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, id), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, true, user.FollowersTable, user.FollowersPrimaryKey...), + ) query.sql = sql.Neighbors(u.driver.Dialect(), step) return query @@ -183,16 +178,11 @@ func (c *UserClient) QueryFollowers(u *User) *UserQuery { func (c *UserClient) QueryFollowing(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.FollowingTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowingPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, id), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, user.FollowingTable, user.FollowingPrimaryKey...), + ) query.sql = sql.Neighbors(u.driver.Dialect(), step) return query diff --git a/examples/m2mrecur/ent/user/where.go b/examples/m2mrecur/ent/user/where.go index 2bcf560aa..80331fc1a 100644 --- a/examples/m2mrecur/ent/user/where.go +++ b/examples/m2mrecur/ent/user/where.go @@ -363,15 +363,12 @@ func NameContainsFold(v string) predicate.User { func HasFollowers() 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(FollowersPrimaryKey[1]). - From(builder.Table(FollowersTable)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(FollowersTable, FieldID), + sql.Edge(sql.M2M, true, FollowersTable, FollowersPrimaryKey...), ) + sql.HasNeighbors(s, step) }, ) } @@ -380,20 +377,16 @@ func HasFollowers() predicate.User { func HasFollowersWith(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(FollowersTable) - t4 := builder.Select(t3.C(FollowersPrimaryKey[1])). - From(t3). - Join(t2). - On(t3.C(FollowersPrimaryKey[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(Table, FieldID), + sql.Edge(sql.M2M, true, FollowersTable, FollowersPrimaryKey...), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } @@ -402,15 +395,12 @@ func HasFollowersWith(preds ...predicate.User) predicate.User { func HasFollowing() 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(FollowingPrimaryKey[0]). - From(builder.Table(FollowingTable)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(FollowingTable, FieldID), + sql.Edge(sql.M2M, false, FollowingTable, FollowingPrimaryKey...), ) + sql.HasNeighbors(s, step) }, ) } @@ -419,20 +409,16 @@ func HasFollowing() predicate.User { func HasFollowingWith(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(FollowingTable) - t4 := builder.Select(t3.C(FollowingPrimaryKey[0])). - From(t3). - Join(t2). - On(t3.C(FollowingPrimaryKey[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, FollowingTable, FollowingPrimaryKey...), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/m2mrecur/ent/user_query.go b/examples/m2mrecur/ent/user_query.go index e80fa77e5..4d0b49d2d 100644 --- a/examples/m2mrecur/ent/user_query.go +++ b/examples/m2mrecur/ent/user_query.go @@ -56,16 +56,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QueryFollowers chains the current query on the followers edge. func (uq *UserQuery) QueryFollowers() *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 = true - step.Edge.Table = user.FollowersTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowersPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, true, user.FollowersTable, user.FollowersPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } @@ -73,16 +68,11 @@ func (uq *UserQuery) QueryFollowers() *UserQuery { // QueryFollowing chains the current query on the following edge. func (uq *UserQuery) QueryFollowing() *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.FollowingTable - step.Edge.Columns = append(step.Edge.Columns, user.FollowingPrimaryKey...) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2M, false, user.FollowingTable, user.FollowingPrimaryKey...), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } diff --git a/examples/o2m2types/ent/client.go b/examples/o2m2types/ent/client.go index 781049886..e4bbf247f 100644 --- a/examples/o2m2types/ent/client.go +++ b/examples/o2m2types/ent/client.go @@ -170,16 +170,11 @@ func (c *PetClient) GetX(ctx context.Context, id int) *Pet { 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 @@ -253,16 +248,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 diff --git a/examples/o2m2types/ent/pet/where.go b/examples/o2m2types/ent/pet/where.go index 3ac267a4d..4a70eac32 100644 --- a/examples/o2m2types/ent/pet/where.go +++ b/examples/o2m2types/ent/pet/where.go @@ -262,8 +262,12 @@ func NameContainsFold(v string) 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) }, ) } @@ -272,13 +276,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) + } + }) }, ) } diff --git a/examples/o2m2types/ent/pet_query.go b/examples/o2m2types/ent/pet_query.go index eacb63d35..ec53ac343 100644 --- a/examples/o2m2types/ent/pet_query.go +++ b/examples/o2m2types/ent/pet_query.go @@ -57,16 +57,11 @@ func (pq *PetQuery) Order(o ...Order) *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 } diff --git a/examples/o2m2types/ent/user/where.go b/examples/o2m2types/ent/user/where.go index 36f4ea661..8dcea2d07 100644 --- a/examples/o2m2types/ent/user/where.go +++ b/examples/o2m2types/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) + } + }) }, ) } diff --git a/examples/o2m2types/ent/user_query.go b/examples/o2m2types/ent/user_query.go index 2df715baf..895d34941 100644 --- a/examples/o2m2types/ent/user_query.go +++ b/examples/o2m2types/ent/user_query.go @@ -57,16 +57,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 } diff --git a/examples/o2mrecur/ent/client.go b/examples/o2mrecur/ent/client.go index c98f444d2..3ff763c4b 100644 --- a/examples/o2mrecur/ent/client.go +++ b/examples/o2mrecur/ent/client.go @@ -164,16 +164,11 @@ func (c *NodeClient) GetX(ctx context.Context, id int) *Node { func (c *NodeClient) QueryParent(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = node.ParentTable - step.Edge.Columns = append(step.Edge.Columns, node.ParentColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, id), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.M2O, true, node.ParentTable, node.ParentColumn), + ) query.sql = sql.Neighbors(n.driver.Dialect(), step) return query @@ -183,16 +178,11 @@ func (c *NodeClient) QueryParent(n *Node) *NodeQuery { func (c *NodeClient) QueryChildren(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = node.ChildrenTable - step.Edge.Columns = append(step.Edge.Columns, node.ChildrenColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, id), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2M, false, node.ChildrenTable, node.ChildrenColumn), + ) query.sql = sql.Neighbors(n.driver.Dialect(), step) return query diff --git a/examples/o2mrecur/ent/node/where.go b/examples/o2mrecur/ent/node/where.go index 3294fb997..11dc9ed0a 100644 --- a/examples/o2mrecur/ent/node/where.go +++ b/examples/o2mrecur/ent/node/where.go @@ -217,8 +217,12 @@ func ValueLTE(v int) predicate.Node { func HasParent() predicate.Node { return predicate.Node( func(s *sql.Selector) { - t1 := s.Table() - s.Where(sql.NotNull(t1.C(ParentColumn))) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(ParentTable, FieldID), + sql.Edge(sql.M2O, true, ParentTable, ParentColumn), + ) + sql.HasNeighbors(s, step) }, ) } @@ -227,13 +231,16 @@ func HasParent() predicate.Node { func HasParentWith(preds ...predicate.Node) predicate.Node { return predicate.Node( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(FieldID).From(builder.Table(ParentTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(ParentColumn), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(Table, FieldID), + sql.Edge(sql.M2O, true, ParentTable, ParentColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } @@ -242,16 +249,12 @@ func HasParentWith(preds ...predicate.Node) predicate.Node { func HasChildren() predicate.Node { return predicate.Node( func(s *sql.Selector) { - t1 := s.Table() - builder := sql.Dialect(s.Dialect()) - s.Where( - sql.In( - t1.C(FieldID), - builder.Select(ChildrenColumn). - From(builder.Table(ChildrenTable)). - Where(sql.NotNull(ChildrenColumn)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(ChildrenTable, FieldID), + sql.Edge(sql.O2M, false, ChildrenTable, ChildrenColumn), ) + sql.HasNeighbors(s, step) }, ) } @@ -260,13 +263,16 @@ func HasChildren() predicate.Node { func HasChildrenWith(preds ...predicate.Node) predicate.Node { return predicate.Node( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(ChildrenColumn).From(builder.Table(ChildrenTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(FieldID), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(Table, FieldID), + sql.Edge(sql.O2M, false, ChildrenTable, ChildrenColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/o2mrecur/ent/node_query.go b/examples/o2mrecur/ent/node_query.go index 9e7ff03da..7ae9d23d5 100644 --- a/examples/o2mrecur/ent/node_query.go +++ b/examples/o2mrecur/ent/node_query.go @@ -56,16 +56,11 @@ func (nq *NodeQuery) Order(o ...Order) *NodeQuery { // QueryParent chains the current query on the parent edge. func (nq *NodeQuery) QueryParent() *NodeQuery { query := &NodeQuery{config: nq.config} - step := &sql.Step{} - step.From.V = nq.sqlQuery() - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = node.ParentTable - step.Edge.Columns = append(step.Edge.Columns, node.ParentColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, nq.sqlQuery()), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.M2O, true, node.ParentTable, node.ParentColumn), + ) query.sql = sql.SetNeighbors(nq.driver.Dialect(), step) return query } @@ -73,16 +68,11 @@ func (nq *NodeQuery) QueryParent() *NodeQuery { // QueryChildren chains the current query on the children edge. func (nq *NodeQuery) QueryChildren() *NodeQuery { query := &NodeQuery{config: nq.config} - step := &sql.Step{} - step.From.V = nq.sqlQuery() - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = node.ChildrenTable - step.Edge.Columns = append(step.Edge.Columns, node.ChildrenColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, nq.sqlQuery()), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2M, false, node.ChildrenTable, node.ChildrenColumn), + ) query.sql = sql.SetNeighbors(nq.driver.Dialect(), step) return query } diff --git a/examples/o2o2types/ent/card/where.go b/examples/o2o2types/ent/card/where.go index e97be4d61..68f0bdf77 100644 --- a/examples/o2o2types/ent/card/where.go +++ b/examples/o2o2types/ent/card/where.go @@ -365,8 +365,12 @@ func NumberContainsFold(v string) predicate.Card { func HasOwner() predicate.Card { return predicate.Card( 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.O2O, true, OwnerTable, OwnerColumn), + ) + sql.HasNeighbors(s, step) }, ) } @@ -375,13 +379,16 @@ func HasOwner() predicate.Card { func HasOwnerWith(preds ...predicate.User) predicate.Card { return predicate.Card( 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.O2O, true, OwnerTable, OwnerColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/o2o2types/ent/card_query.go b/examples/o2o2types/ent/card_query.go index 968fc22ab..7056d4f95 100644 --- a/examples/o2o2types/ent/card_query.go +++ b/examples/o2o2types/ent/card_query.go @@ -57,16 +57,11 @@ func (cq *CardQuery) Order(o ...Order) *CardQuery { // QueryOwner chains the current query on the owner edge. func (cq *CardQuery) QueryOwner() *UserQuery { query := &UserQuery{config: cq.config} - step := &sql.Step{} - step.From.V = cq.sqlQuery() - step.From.Table = card.Table - step.From.Column = card.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = card.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, card.OwnerColumn) + step := sql.NewStep( + sql.From(card.Table, card.FieldID, cq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, true, card.OwnerTable, card.OwnerColumn), + ) query.sql = sql.SetNeighbors(cq.driver.Dialect(), step) return query } diff --git a/examples/o2o2types/ent/client.go b/examples/o2o2types/ent/client.go index ba900baa6..25405b58d 100644 --- a/examples/o2o2types/ent/client.go +++ b/examples/o2o2types/ent/client.go @@ -170,16 +170,11 @@ func (c *CardClient) GetX(ctx context.Context, id int) *Card { func (c *CardClient) QueryOwner(ca *Card) *UserQuery { query := &UserQuery{config: c.config} id := ca.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = card.Table - step.From.Column = card.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = card.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, card.OwnerColumn) + step := sql.NewStep( + sql.From(card.Table, card.FieldID, id), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, true, card.OwnerTable, card.OwnerColumn), + ) query.sql = sql.Neighbors(ca.driver.Dialect(), step) return query @@ -253,16 +248,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryCard(u *User) *CardQuery { query := &CardQuery{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 = card.Table - step.To.Column = card.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = user.CardTable - step.Edge.Columns = append(step.Edge.Columns, user.CardColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, id), + sql.To(card.Table, card.FieldID), + sql.Edge(sql.O2O, false, user.CardTable, user.CardColumn), + ) query.sql = sql.Neighbors(u.driver.Dialect(), step) return query diff --git a/examples/o2o2types/ent/user/where.go b/examples/o2o2types/ent/user/where.go index 2366b8e92..cb560496d 100644 --- a/examples/o2o2types/ent/user/where.go +++ b/examples/o2o2types/ent/user/where.go @@ -363,16 +363,12 @@ func NameContainsFold(v string) predicate.User { func HasCard() 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(CardColumn). - From(builder.Table(CardTable)). - Where(sql.NotNull(CardColumn)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(CardTable, FieldID), + sql.Edge(sql.O2O, false, CardTable, CardColumn), ) + sql.HasNeighbors(s, step) }, ) } @@ -381,13 +377,16 @@ func HasCard() predicate.User { func HasCardWith(preds ...predicate.Card) predicate.User { return predicate.User( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(CardColumn).From(builder.Table(CardTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(FieldID), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(CardInverseTable, FieldID), + sql.Edge(sql.O2O, false, CardTable, CardColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/o2o2types/ent/user_query.go b/examples/o2o2types/ent/user_query.go index bdc1049fe..6e718c223 100644 --- a/examples/o2o2types/ent/user_query.go +++ b/examples/o2o2types/ent/user_query.go @@ -57,16 +57,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QueryCard chains the current query on the card edge. func (uq *UserQuery) QueryCard() *CardQuery { query := &CardQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = card.Table - step.To.Column = card.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = user.CardTable - step.Edge.Columns = append(step.Edge.Columns, user.CardColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(card.Table, card.FieldID), + sql.Edge(sql.O2O, false, user.CardTable, user.CardColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } diff --git a/examples/o2obidi/ent/client.go b/examples/o2obidi/ent/client.go index 1f5f60d2d..333e7ed3d 100644 --- a/examples/o2obidi/ent/client.go +++ b/examples/o2obidi/ent/client.go @@ -164,16 +164,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QuerySpouse(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.O2O - step.Edge.Inverse = false - step.Edge.Table = user.SpouseTable - step.Edge.Columns = append(step.Edge.Columns, user.SpouseColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, id), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, false, user.SpouseTable, user.SpouseColumn), + ) query.sql = sql.Neighbors(u.driver.Dialect(), step) return query diff --git a/examples/o2obidi/ent/user/where.go b/examples/o2obidi/ent/user/where.go index 876c73c71..9905efb9e 100644 --- a/examples/o2obidi/ent/user/where.go +++ b/examples/o2obidi/ent/user/where.go @@ -363,16 +363,12 @@ func NameContainsFold(v string) predicate.User { func HasSpouse() 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(SpouseColumn). - From(builder.Table(SpouseTable)). - Where(sql.NotNull(SpouseColumn)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(SpouseTable, FieldID), + sql.Edge(sql.O2O, false, SpouseTable, SpouseColumn), ) + sql.HasNeighbors(s, step) }, ) } @@ -381,13 +377,16 @@ func HasSpouse() predicate.User { func HasSpouseWith(preds ...predicate.User) predicate.User { return predicate.User( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(SpouseColumn).From(builder.Table(SpouseTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(FieldID), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(Table, FieldID), + sql.Edge(sql.O2O, false, SpouseTable, SpouseColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/o2obidi/ent/user_query.go b/examples/o2obidi/ent/user_query.go index a8b687d2d..3bf449fa1 100644 --- a/examples/o2obidi/ent/user_query.go +++ b/examples/o2obidi/ent/user_query.go @@ -56,16 +56,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QuerySpouse chains the current query on the spouse edge. func (uq *UserQuery) QuerySpouse() *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.O2O - step.Edge.Inverse = false - step.Edge.Table = user.SpouseTable - step.Edge.Columns = append(step.Edge.Columns, user.SpouseColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.O2O, false, user.SpouseTable, user.SpouseColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } diff --git a/examples/o2orecur/ent/client.go b/examples/o2orecur/ent/client.go index bb26ebfd9..26f9d137a 100644 --- a/examples/o2orecur/ent/client.go +++ b/examples/o2orecur/ent/client.go @@ -164,16 +164,11 @@ func (c *NodeClient) GetX(ctx context.Context, id int) *Node { func (c *NodeClient) QueryPrev(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = node.PrevTable - step.Edge.Columns = append(step.Edge.Columns, node.PrevColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, id), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2O, true, node.PrevTable, node.PrevColumn), + ) query.sql = sql.Neighbors(n.driver.Dialect(), step) return query @@ -183,16 +178,11 @@ func (c *NodeClient) QueryPrev(n *Node) *NodeQuery { func (c *NodeClient) QueryNext(n *Node) *NodeQuery { query := &NodeQuery{config: c.config} id := n.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = node.NextTable - step.Edge.Columns = append(step.Edge.Columns, node.NextColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, id), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2O, false, node.NextTable, node.NextColumn), + ) query.sql = sql.Neighbors(n.driver.Dialect(), step) return query diff --git a/examples/o2orecur/ent/node/where.go b/examples/o2orecur/ent/node/where.go index 6ef6b490e..c590927ad 100644 --- a/examples/o2orecur/ent/node/where.go +++ b/examples/o2orecur/ent/node/where.go @@ -217,8 +217,12 @@ func ValueLTE(v int) predicate.Node { func HasPrev() predicate.Node { return predicate.Node( func(s *sql.Selector) { - t1 := s.Table() - s.Where(sql.NotNull(t1.C(PrevColumn))) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(PrevTable, FieldID), + sql.Edge(sql.O2O, true, PrevTable, PrevColumn), + ) + sql.HasNeighbors(s, step) }, ) } @@ -227,13 +231,16 @@ func HasPrev() predicate.Node { func HasPrevWith(preds ...predicate.Node) predicate.Node { return predicate.Node( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(FieldID).From(builder.Table(PrevTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(PrevColumn), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(Table, FieldID), + sql.Edge(sql.O2O, true, PrevTable, PrevColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } @@ -242,16 +249,12 @@ func HasPrevWith(preds ...predicate.Node) predicate.Node { func HasNext() predicate.Node { return predicate.Node( func(s *sql.Selector) { - t1 := s.Table() - builder := sql.Dialect(s.Dialect()) - s.Where( - sql.In( - t1.C(FieldID), - builder.Select(NextColumn). - From(builder.Table(NextTable)). - Where(sql.NotNull(NextColumn)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(NextTable, FieldID), + sql.Edge(sql.O2O, false, NextTable, NextColumn), ) + sql.HasNeighbors(s, step) }, ) } @@ -260,13 +263,16 @@ func HasNext() predicate.Node { func HasNextWith(preds ...predicate.Node) predicate.Node { return predicate.Node( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(NextColumn).From(builder.Table(NextTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(FieldID), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(Table, FieldID), + sql.Edge(sql.O2O, false, NextTable, NextColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } diff --git a/examples/o2orecur/ent/node_query.go b/examples/o2orecur/ent/node_query.go index 23db74fa0..912443dec 100644 --- a/examples/o2orecur/ent/node_query.go +++ b/examples/o2orecur/ent/node_query.go @@ -56,16 +56,11 @@ func (nq *NodeQuery) Order(o ...Order) *NodeQuery { // QueryPrev chains the current query on the prev edge. func (nq *NodeQuery) QueryPrev() *NodeQuery { query := &NodeQuery{config: nq.config} - step := &sql.Step{} - step.From.V = nq.sqlQuery() - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = true - step.Edge.Table = node.PrevTable - step.Edge.Columns = append(step.Edge.Columns, node.PrevColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, nq.sqlQuery()), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2O, true, node.PrevTable, node.PrevColumn), + ) query.sql = sql.SetNeighbors(nq.driver.Dialect(), step) return query } @@ -73,16 +68,11 @@ func (nq *NodeQuery) QueryPrev() *NodeQuery { // QueryNext chains the current query on the next edge. func (nq *NodeQuery) QueryNext() *NodeQuery { query := &NodeQuery{config: nq.config} - step := &sql.Step{} - step.From.V = nq.sqlQuery() - step.From.Table = node.Table - step.From.Column = node.FieldID - step.To.Table = node.Table - step.To.Column = node.FieldID - step.Edge.Rel = sql.O2O - step.Edge.Inverse = false - step.Edge.Table = node.NextTable - step.Edge.Columns = append(step.Edge.Columns, node.NextColumn) + step := sql.NewStep( + sql.From(node.Table, node.FieldID, nq.sqlQuery()), + sql.To(node.Table, node.FieldID), + sql.Edge(sql.O2O, false, node.NextTable, node.NextColumn), + ) query.sql = sql.SetNeighbors(nq.driver.Dialect(), step) return query } diff --git a/examples/start/ent/car/where.go b/examples/start/ent/car/where.go index e71a48102..eb3e9d5b4 100644 --- a/examples/start/ent/car/where.go +++ b/examples/start/ent/car/where.go @@ -365,8 +365,12 @@ func RegisteredAtLTE(v time.Time) predicate.Car { func HasOwner() predicate.Car { return predicate.Car( 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) }, ) } @@ -375,13 +379,16 @@ func HasOwner() predicate.Car { func HasOwnerWith(preds ...predicate.User) predicate.Car { return predicate.Car( 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) + } + }) }, ) } diff --git a/examples/start/ent/car_query.go b/examples/start/ent/car_query.go index a69ba4016..05915437b 100644 --- a/examples/start/ent/car_query.go +++ b/examples/start/ent/car_query.go @@ -57,16 +57,11 @@ func (cq *CarQuery) Order(o ...Order) *CarQuery { // QueryOwner chains the current query on the owner edge. func (cq *CarQuery) QueryOwner() *UserQuery { query := &UserQuery{config: cq.config} - step := &sql.Step{} - step.From.V = cq.sqlQuery() - step.From.Table = car.Table - step.From.Column = car.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = car.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, car.OwnerColumn) + step := sql.NewStep( + sql.From(car.Table, car.FieldID, cq.sqlQuery()), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2O, true, car.OwnerTable, car.OwnerColumn), + ) query.sql = sql.SetNeighbors(cq.driver.Dialect(), step) return query } diff --git a/examples/start/ent/client.go b/examples/start/ent/client.go index a3bb0f084..31c1ffefc 100644 --- a/examples/start/ent/client.go +++ b/examples/start/ent/client.go @@ -176,16 +176,11 @@ func (c *CarClient) GetX(ctx context.Context, id int) *Car { func (c *CarClient) QueryOwner(ca *Car) *UserQuery { query := &UserQuery{config: c.config} id := ca.ID - step := &sql.Step{} - step.From.V = id - step.From.Table = car.Table - step.From.Column = car.FieldID - step.To.Table = user.Table - step.To.Column = user.FieldID - step.Edge.Rel = sql.M2O - step.Edge.Inverse = true - step.Edge.Table = car.OwnerTable - step.Edge.Columns = append(step.Edge.Columns, car.OwnerColumn) + step := sql.NewStep( + sql.From(car.Table, car.FieldID, id), + sql.To(user.Table, user.FieldID), + sql.Edge(sql.M2O, true, car.OwnerTable, car.OwnerColumn), + ) query.sql = sql.Neighbors(ca.driver.Dialect(), step) return query @@ -259,16 +254,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 @@ -342,16 +332,11 @@ func (c *UserClient) GetX(ctx context.Context, id int) *User { func (c *UserClient) QueryCars(u *User) *CarQuery { query := &CarQuery{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 = car.Table - step.To.Column = car.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = user.CarsTable - step.Edge.Columns = append(step.Edge.Columns, user.CarsColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, id), + sql.To(car.Table, car.FieldID), + sql.Edge(sql.O2M, false, user.CarsTable, user.CarsColumn), + ) query.sql = sql.Neighbors(u.driver.Dialect(), step) return query @@ -361,16 +346,11 @@ func (c *UserClient) QueryCars(u *User) *CarQuery { 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 diff --git a/examples/start/ent/group/where.go b/examples/start/ent/group/where.go index ba9bf14ac..38a7ee992 100644 --- a/examples/start/ent/group/where.go +++ b/examples/start/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) + } + }) }, ) } diff --git a/examples/start/ent/group_query.go b/examples/start/ent/group_query.go index 3e94777f3..8a14c96af 100644 --- a/examples/start/ent/group_query.go +++ b/examples/start/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 } diff --git a/examples/start/ent/user/where.go b/examples/start/ent/user/where.go index b3f121eb1..544198098 100644 --- a/examples/start/ent/user/where.go +++ b/examples/start/ent/user/where.go @@ -363,16 +363,12 @@ func NameContainsFold(v string) predicate.User { func HasCars() 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(CarsColumn). - From(builder.Table(CarsTable)). - Where(sql.NotNull(CarsColumn)), - ), + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(CarsTable, FieldID), + sql.Edge(sql.O2M, false, CarsTable, CarsColumn), ) + sql.HasNeighbors(s, step) }, ) } @@ -381,13 +377,16 @@ func HasCars() predicate.User { func HasCarsWith(preds ...predicate.Car) predicate.User { return predicate.User( func(s *sql.Selector) { - builder := sql.Dialect(s.Dialect()) - t1 := s.Table() - t2 := builder.Select(CarsColumn).From(builder.Table(CarsTable)) - for _, p := range preds { - p(t2) - } - s.Where(sql.In(t1.C(FieldID), t2)) + step := sql.NewStep( + sql.From(Table, FieldID), + sql.To(CarsInverseTable, FieldID), + sql.Edge(sql.O2M, false, CarsTable, CarsColumn), + ) + sql.HasNeighborsWith(s, step, func(s *sql.Selector) { + for _, p := range preds { + p(s) + } + }) }, ) } @@ -396,15 +395,12 @@ func HasCarsWith(preds ...predicate.Car) 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) }, ) } @@ -413,20 +409,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) + } + }) }, ) } diff --git a/examples/start/ent/user_query.go b/examples/start/ent/user_query.go index 534904aec..93a678ddf 100644 --- a/examples/start/ent/user_query.go +++ b/examples/start/ent/user_query.go @@ -58,16 +58,11 @@ func (uq *UserQuery) Order(o ...Order) *UserQuery { // QueryCars chains the current query on the cars edge. func (uq *UserQuery) QueryCars() *CarQuery { query := &CarQuery{config: uq.config} - step := &sql.Step{} - step.From.V = uq.sqlQuery() - step.From.Table = user.Table - step.From.Column = user.FieldID - step.To.Table = car.Table - step.To.Column = car.FieldID - step.Edge.Rel = sql.O2M - step.Edge.Inverse = false - step.Edge.Table = user.CarsTable - step.Edge.Columns = append(step.Edge.Columns, user.CarsColumn) + step := sql.NewStep( + sql.From(user.Table, user.FieldID, uq.sqlQuery()), + sql.To(car.Table, car.FieldID), + sql.Edge(sql.O2M, false, user.CarsTable, user.CarsColumn), + ) query.sql = sql.SetNeighbors(uq.driver.Dialect(), step) return query } @@ -75,16 +70,11 @@ func (uq *UserQuery) QueryCars() *CarQuery { // 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 } diff --git a/examples/traversal/ent/client.go b/examples/traversal/ent/client.go index 854b36a21..ce77595cf 100644 --- a/examples/traversal/ent/client.go +++ b/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 diff --git a/examples/traversal/ent/group/where.go b/examples/traversal/ent/group/where.go index 94e7cef14..87ccccc71 100644 --- a/examples/traversal/ent/group/where.go +++ b/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) + } + }) }, ) } diff --git a/examples/traversal/ent/group_query.go b/examples/traversal/ent/group_query.go index 9456004fd..5e271d0b5 100644 --- a/examples/traversal/ent/group_query.go +++ b/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 } diff --git a/examples/traversal/ent/pet/where.go b/examples/traversal/ent/pet/where.go index cfba7ebb2..444fda723 100644 --- a/examples/traversal/ent/pet/where.go +++ b/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) + } + }) }, ) } diff --git a/examples/traversal/ent/pet_query.go b/examples/traversal/ent/pet_query.go index e1c084583..8ba9513cf 100644 --- a/examples/traversal/ent/pet_query.go +++ b/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 } diff --git a/examples/traversal/ent/user/where.go b/examples/traversal/ent/user/where.go index d4dc31fd1..22e7df988 100644 --- a/examples/traversal/ent/user/where.go +++ b/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) + } + }) }, ) } diff --git a/examples/traversal/ent/user_query.go b/examples/traversal/ent/user_query.go index da0410b70..6e8ccc716 100644 --- a/examples/traversal/ent/user_query.go +++ b/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 }