golang/ent
1
0
Fork 0
mirror of https://github.com/ent/ent.git synced 2026-05-22 09:31:45 +03:00
Code Issues Packages Projects Releases Wiki Activity

entc/gen: change neighbors query to use Step builder

Browse Source 
Summary: Pull Request resolved: https://github.com/facebookincubator/ent/pull/202

Reviewed By: alexsn

Differential Revision: D18725770

fbshipit-source-id: d7720ac89f55022a7721edc7df15fab1d6e3672c
This commit is contained in:
Ariel Mashraki
2019-11-27 06:11:04 -08:00
committed by Facebook Github Bot
parent 0e73d57571
commit ed3747ff82
15 changed files with 174 additions and 333 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
entc/gen/internal/bindata.go
View File

File diff suppressed because one or more lines are too long

23
entc/gen/template/dialect/sql/query.tmpl
View File

@@ -88,19 +88,20 @@ func ({{ $receiver }} *{{ $builder }}) sqlQuery() *sql.Selector {
{{/* query/path defines the query generation for path of a given edge. */}}
{{ define "dialect/sql/query/path" }}
{{- $n := $ }}
{{- $n := $ }} {{/* the node we start the query from. */}}
{{- $e := $.Scope.Edge }} {{/* the edge we need to genegrate the path to. */}}
{{- $receiver := $.Scope.Receiver }}
step := &sql.Step{}
step.From.V = {{ $receiver }}.sqlQuery()
step.From.Table = {{ $n.Package }}.Table
step.From.Column = {{ $n.Package }}.{{ $n.ID.Constant }}
step.To.Table = {{ $e.Type.Package }}.Table
step.To.Column = {{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}
step.Edge.Rel = sql.{{ $e.Rel.Type }}
step.Edge.Inverse = {{ $e.IsInverse }}
step.Edge.Table = {{ $n.Package }}.{{ $e.TableConstant }}
step.Edge.Columns = append(step.Edge.Columns, {{ if $e.M2M }}{{ $n.Package }}.{{ $e.PKConstant }}...{{ else }}{{ $n.Package }}.{{ $e.ColumnConstant }}{{ end }})
step := sql.NewStep(
sql.From({{ $n.Package }}.Table, {{ $n.Package }}.{{ $n.ID.Constant }}, {{ $receiver }}.sqlQuery()),
sql.To({{ $e.Type.Package }}.Table, {{ $e.Type.Package }}.{{ $e.Type.ID.Constant }}),
sql.Edge(sql.{{ $e.Rel.Type }}, {{ $e.IsInverse }}, {{ $n.Package }}.{{ $e.TableConstant }},
{{- if $e.M2M -}}
{{ $n.Package }}.{{ $e.PKConstant }}...
{{- else -}}
{{ $n.Package }}.{{ $e.ColumnConstant }}
{{- end -}}
),
)
query.sql = sql.SetNeighbors({{ $receiver }}.driver.Dialect(), step)
{{ end }}

15
entc/integration/customid/ent/group_query.go
View File

@@ -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
}

15
entc/integration/customid/ent/user_query.go
View File

@@ -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
}

15
entc/integration/ent/card_query.go
View File

@@ -65,16 +65,11 @@ func (cq *CardQuery) QueryOwner() *UserQuery {
query := &UserQuery{config: cq.config}
switch cq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := cq.gremlinQuery()

30
entc/integration/ent/file_query.go
View File

@@ -66,16 +66,11 @@ func (fq *FileQuery) QueryOwner() *UserQuery {
query := &UserQuery{config: fq.config}
switch fq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = fq.sqlQuery()
step.From.Table = file.Table
step.From.Column = file.FieldID
step.To.Table = user.Table
step.To.Column = user.FieldID
step.Edge.Rel = sql.M2O
step.Edge.Inverse = true
step.Edge.Table = file.OwnerTable
step.Edge.Columns = append(step.Edge.Columns, file.OwnerColumn)
step := sql.NewStep(
sql.From(file.Table, file.FieldID, fq.sqlQuery()),
sql.To(user.Table, user.FieldID),
sql.Edge(sql.M2O, true, file.OwnerTable, file.OwnerColumn),
)
query.sql = sql.SetNeighbors(fq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := fq.gremlinQuery()
@@ -89,16 +84,11 @@ func (fq *FileQuery) QueryType() *FileTypeQuery {
query := &FileTypeQuery{config: fq.config}
switch fq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = fq.sqlQuery()
step.From.Table = file.Table
step.From.Column = file.FieldID
step.To.Table = filetype.Table
step.To.Column = filetype.FieldID
step.Edge.Rel = sql.M2O
step.Edge.Inverse = true
step.Edge.Table = file.TypeTable
step.Edge.Columns = append(step.Edge.Columns, file.TypeColumn)
step := sql.NewStep(
sql.From(file.Table, file.FieldID, fq.sqlQuery()),
sql.To(filetype.Table, filetype.FieldID),
sql.Edge(sql.M2O, true, file.TypeTable, file.TypeColumn),
)
query.sql = sql.SetNeighbors(fq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := fq.gremlinQuery()

15
entc/integration/ent/filetype_query.go
View File

@@ -65,16 +65,11 @@ func (ftq *FileTypeQuery) QueryFiles() *FileQuery {
query := &FileQuery{config: ftq.config}
switch ftq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = ftq.sqlQuery()
step.From.Table = filetype.Table
step.From.Column = filetype.FieldID
step.To.Table = file.Table
step.To.Column = file.FieldID
step.Edge.Rel = sql.O2M
step.Edge.Inverse = false
step.Edge.Table = filetype.FilesTable
step.Edge.Columns = append(step.Edge.Columns, filetype.FilesColumn)
step := sql.NewStep(
sql.From(filetype.Table, filetype.FieldID, ftq.sqlQuery()),
sql.To(file.Table, file.FieldID),
sql.Edge(sql.O2M, false, filetype.FilesTable, filetype.FilesColumn),
)
query.sql = sql.SetNeighbors(ftq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := ftq.gremlinQuery()

60
entc/integration/ent/group_query.go
View File

@@ -67,16 +67,11 @@ func (gq *GroupQuery) QueryFiles() *FileQuery {
query := &FileQuery{config: gq.config}
switch gq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = gq.sqlQuery()
step.From.Table = group.Table
step.From.Column = group.FieldID
step.To.Table = file.Table
step.To.Column = file.FieldID
step.Edge.Rel = sql.O2M
step.Edge.Inverse = false
step.Edge.Table = group.FilesTable
step.Edge.Columns = append(step.Edge.Columns, group.FilesColumn)
step := sql.NewStep(
sql.From(group.Table, group.FieldID, gq.sqlQuery()),
sql.To(file.Table, file.FieldID),
sql.Edge(sql.O2M, false, group.FilesTable, group.FilesColumn),
)
query.sql = sql.SetNeighbors(gq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := gq.gremlinQuery()
@@ -90,16 +85,11 @@ func (gq *GroupQuery) QueryBlocked() *UserQuery {
query := &UserQuery{config: gq.config}
switch gq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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.O2M
step.Edge.Inverse = false
step.Edge.Table = group.BlockedTable
step.Edge.Columns = append(step.Edge.Columns, group.BlockedColumn)
step := sql.NewStep(
sql.From(group.Table, group.FieldID, gq.sqlQuery()),
sql.To(user.Table, user.FieldID),
sql.Edge(sql.O2M, false, group.BlockedTable, group.BlockedColumn),
)
query.sql = sql.SetNeighbors(gq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := gq.gremlinQuery()
@@ -113,16 +103,11 @@ func (gq *GroupQuery) QueryUsers() *UserQuery {
query := &UserQuery{config: gq.config}
switch gq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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 = true
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, true, group.UsersTable, group.UsersPrimaryKey...),
)
query.sql = sql.SetNeighbors(gq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := gq.gremlinQuery()
@@ -136,16 +121,11 @@ func (gq *GroupQuery) QueryInfo() *GroupInfoQuery {
query := &GroupInfoQuery{config: gq.config}
switch gq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = gq.sqlQuery()
step.From.Table = group.Table
step.From.Column = group.FieldID
step.To.Table = groupinfo.Table
step.To.Column = groupinfo.FieldID
step.Edge.Rel = sql.M2O
step.Edge.Inverse = false
step.Edge.Table = group.InfoTable
step.Edge.Columns = append(step.Edge.Columns, group.InfoColumn)
step := sql.NewStep(
sql.From(group.Table, group.FieldID, gq.sqlQuery()),
sql.To(groupinfo.Table, groupinfo.FieldID),
sql.Edge(sql.M2O, false, group.InfoTable, group.InfoColumn),
)
query.sql = sql.SetNeighbors(gq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := gq.gremlinQuery()

15
entc/integration/ent/groupinfo_query.go
View File

@@ -65,16 +65,11 @@ func (giq *GroupInfoQuery) QueryGroups() *GroupQuery {
query := &GroupQuery{config: giq.config}
switch giq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = giq.sqlQuery()
step.From.Table = groupinfo.Table
step.From.Column = groupinfo.FieldID
step.To.Table = group.Table
step.To.Column = group.FieldID
step.Edge.Rel = sql.O2M
step.Edge.Inverse = true
step.Edge.Table = groupinfo.GroupsTable
step.Edge.Columns = append(step.Edge.Columns, groupinfo.GroupsColumn)
step := sql.NewStep(
sql.From(groupinfo.Table, groupinfo.FieldID, giq.sqlQuery()),
sql.To(group.Table, group.FieldID),
sql.Edge(sql.O2M, true, groupinfo.GroupsTable, groupinfo.GroupsColumn),
)
query.sql = sql.SetNeighbors(giq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := giq.gremlinQuery()

30
entc/integration/ent/node_query.go
View File

@@ -64,16 +64,11 @@ func (nq *NodeQuery) QueryPrev() *NodeQuery {
query := &NodeQuery{config: nq.config}
switch nq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := nq.gremlinQuery()
@@ -87,16 +82,11 @@ func (nq *NodeQuery) QueryNext() *NodeQuery {
query := &NodeQuery{config: nq.config}
switch nq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := nq.gremlinQuery()

30
entc/integration/ent/pet_query.go
View File

@@ -65,16 +65,11 @@ func (pq *PetQuery) QueryTeam() *UserQuery {
query := &UserQuery{config: pq.config}
switch pq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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.O2O
step.Edge.Inverse = true
step.Edge.Table = pet.TeamTable
step.Edge.Columns = append(step.Edge.Columns, pet.TeamColumn)
step := sql.NewStep(
sql.From(pet.Table, pet.FieldID, pq.sqlQuery()),
sql.To(user.Table, user.FieldID),
sql.Edge(sql.O2O, true, pet.TeamTable, pet.TeamColumn),
)
query.sql = sql.SetNeighbors(pq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := pq.gremlinQuery()
@@ -88,16 +83,11 @@ func (pq *PetQuery) QueryOwner() *UserQuery {
query := &UserQuery{config: pq.config}
switch pq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := pq.gremlinQuery()

165
entc/integration/ent/user_query.go
View File

@@ -68,16 +68,11 @@ func (uq *UserQuery) QueryCard() *CardQuery {
query := &CardQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -91,16 +86,11 @@ func (uq *UserQuery) QueryPets() *PetQuery {
query := &PetQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -114,16 +104,11 @@ func (uq *UserQuery) QueryFiles() *FileQuery {
query := &FileQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
step := &sql.Step{}
step.From.V = uq.sqlQuery()
step.From.Table = user.Table
step.From.Column = user.FieldID
step.To.Table = file.Table
step.To.Column = file.FieldID
step.Edge.Rel = sql.O2M
step.Edge.Inverse = false
step.Edge.Table = user.FilesTable
step.Edge.Columns = append(step.Edge.Columns, user.FilesColumn)
step := sql.NewStep(
sql.From(user.Table, user.FieldID, uq.sqlQuery()),
sql.To(file.Table, file.FieldID),
sql.Edge(sql.O2M, false, user.FilesTable, user.FilesColumn),
)
query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -137,16 +122,11 @@ func (uq *UserQuery) QueryGroups() *GroupQuery {
query := &GroupQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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 = false
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, false, user.GroupsTable, user.GroupsPrimaryKey...),
)
query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -160,16 +140,11 @@ func (uq *UserQuery) QueryFriends() *UserQuery {
query := &UserQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -183,16 +158,11 @@ func (uq *UserQuery) QueryFollowers() *UserQuery {
query := &UserQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -206,16 +176,11 @@ func (uq *UserQuery) QueryFollowing() *UserQuery {
query := &UserQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -229,16 +194,11 @@ func (uq *UserQuery) QueryTeam() *PetQuery {
query := &PetQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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.O2O
step.Edge.Inverse = false
step.Edge.Table = user.TeamTable
step.Edge.Columns = append(step.Edge.Columns, user.TeamColumn)
step := sql.NewStep(
sql.From(user.Table, user.FieldID, uq.sqlQuery()),
sql.To(pet.Table, pet.FieldID),
sql.Edge(sql.O2O, false, user.TeamTable, user.TeamColumn),
)
query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -252,16 +212,11 @@ func (uq *UserQuery) QuerySpouse() *UserQuery {
query := &UserQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -275,16 +230,11 @@ func (uq *UserQuery) QueryChildren() *UserQuery {
query := &UserQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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.O2M
step.Edge.Inverse = true
step.Edge.Table = user.ChildrenTable
step.Edge.Columns = append(step.Edge.Columns, user.ChildrenColumn)
step := sql.NewStep(
sql.From(user.Table, user.FieldID, uq.sqlQuery()),
sql.To(user.Table, user.FieldID),
sql.Edge(sql.O2M, true, user.ChildrenTable, user.ChildrenColumn),
)
query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()
@@ -298,16 +248,11 @@ func (uq *UserQuery) QueryParent() *UserQuery {
query := &UserQuery{config: uq.config}
switch uq.driver.Dialect() {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
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.M2O
step.Edge.Inverse = false
step.Edge.Table = user.ParentTable
step.Edge.Columns = append(step.Edge.Columns, user.ParentColumn)
step := sql.NewStep(
sql.From(user.Table, user.FieldID, uq.sqlQuery()),
sql.To(user.Table, user.FieldID),
sql.Edge(sql.M2O, false, user.ParentTable, user.ParentColumn),
)
query.sql = sql.SetNeighbors(uq.driver.Dialect(), step)
case dialect.Gremlin:
gremlin := uq.gremlinQuery()

45
entc/integration/idtype/ent/user_query.go
View File

@@ -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
}
@@ -73,16 +68,11 @@ func (uq *UserQuery) QuerySpouse() *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
}
@@ -90,16 +80,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
}

15
entc/integration/template/ent/pet_query.go
View File

@@ -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
}

30
entc/integration/template/ent/user_query.go
View File

@@ -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
}
@@ -74,16 +69,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
}