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

entc/gen: move sql-update-one to sqlgraph

Browse Source
This commit is contained in:
Ariel Mashraki
2019-12-18 19:25:46 +02:00
parent 1bbe460259
commit 7fde9b7642
53 changed files with 8834 additions and 7859 deletions
Download Patch File Download Diff File Expand all files Collapse all files

368
examples/traversal/ent/group_update.go
View File

@@ -12,9 +12,11 @@ import (
"fmt"
"github.com/facebookincubator/ent/dialect/sql"
"github.com/facebookincubator/ent/dialect/sql/sqlgraph"
"github.com/facebookincubator/ent/examples/traversal/ent/group"
"github.com/facebookincubator/ent/examples/traversal/ent/predicate"
"github.com/facebookincubator/ent/examples/traversal/ent/user"
"github.com/facebookincubator/ent/schema/field"
)
// GroupUpdate is the builder for updating Group entities.
@@ -139,104 +141,110 @@ func (gu *GroupUpdate) ExecX(ctx context.Context) {
}
func (gu *GroupUpdate) sqlSave(ctx context.Context) (n int, err error) {
var (
builder = sql.Dialect(gu.driver.Dialect())
selector = builder.Select(group.FieldID).From(builder.Table(group.Table))
)
for _, p := range gu.predicates {
p(selector)
spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: group.Table,
Columns: group.Columns,
ID: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
rows := &sql.Rows{}
query, args := selector.Query()
if err = gu.driver.Query(ctx, query, args, rows); err != nil {
return 0, err
}
defer rows.Close()
var ids []int
for rows.Next() {
var id int
if err := rows.Scan(&id); err != nil {
return 0, fmt.Errorf("ent: failed reading id: %v", err)
}
ids = append(ids, id)
}
if len(ids) == 0 {
return 0, nil
}
tx, err := gu.driver.Tx(ctx)
if err != nil {
return 0, err
}
var (
res sql.Result
updater = builder.Update(group.Table)
)
updater = updater.Where(sql.InInts(group.FieldID, ids...))
if value := gu.name; value != nil {
updater.Set(group.FieldName, *value)
}
if !updater.Empty() {
query, args := updater.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
}
if len(gu.removedUsers) > 0 {
eids := make([]int, len(gu.removedUsers))
for eid := range gu.removedUsers {
eids = append(eids, eid)
}
query, args := builder.Delete(group.UsersTable).
Where(sql.InInts(group.UsersPrimaryKey[0], ids...)).
Where(sql.InInts(group.UsersPrimaryKey[1], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
}
if len(gu.users) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range gu.users {
values = append(values, []int{id, eid})
if ps := gu.predicates; len(ps) > 0 {
spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
builder := builder.Insert(group.UsersTable).
Columns(group.UsersPrimaryKey[0], group.UsersPrimaryKey[1])
for _, v := range values {
builder.Values(v[0], v[1])
}
if value := gu.name; value != nil {
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: *value,
Column: group.FieldName,
})
}
if nodes := gu.removedUsers; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: group.UsersTable,
Columns: group.UsersPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if nodes := gu.users; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: group.UsersTable,
Columns: group.UsersPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if gu.clearedAdmin {
query, args := builder.Update(group.AdminTable).
SetNull(group.AdminColumn).
Where(sql.InInts(user.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: false,
Table: group.AdminTable,
Columns: []string{group.AdminColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(gu.admin) > 0 {
for eid := range gu.admin {
query, args := builder.Update(group.AdminTable).
Set(group.AdminColumn, eid).
Where(sql.InInts(group.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
if nodes := gu.admin; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: false,
Table: group.AdminTable,
Columns: []string{group.AdminColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if err = tx.Commit(); err != nil {
if n, err = sqlgraph.UpdateNodes(ctx, gu.driver, spec); err != nil {
if cerr, ok := isSQLConstraintError(err); ok {
err = cerr
}
return 0, err
}
return len(ids), nil
return n, nil
}
// GroupUpdateOne is the builder for updating a single Group entity.
@@ -355,105 +363,123 @@ func (guo *GroupUpdateOne) ExecX(ctx context.Context) {
}
func (guo *GroupUpdateOne) sqlSave(ctx context.Context) (gr *Group, err error) {
var (
builder = sql.Dialect(guo.driver.Dialect())
selector = builder.Select(group.Columns...).From(builder.Table(group.Table))
)
group.ID(guo.id)(selector)
rows := &sql.Rows{}
query, args := selector.Query()
if err = guo.driver.Query(ctx, query, args, rows); err != nil {
return nil, err
spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: group.Table,
Columns: group.Columns,
ID: &sqlgraph.FieldSpec{
Value: guo.id,
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
defer rows.Close()
var ids []int
for rows.Next() {
var id int
gr = &Group{config: guo.config}
if err := gr.FromRows(rows); err != nil {
return nil, fmt.Errorf("ent: failed scanning row into Group: %v", err)
}
id = gr.ID
ids = append(ids, id)
}
switch n := len(ids); {
case n == 0:
return nil, &ErrNotFound{fmt.Sprintf("Group with id: %v", guo.id)}
case n > 1:
return nil, fmt.Errorf("ent: more than one Group with the same id: %v", guo.id)
}
tx, err := guo.driver.Tx(ctx)
if err != nil {
return nil, err
}
var (
res sql.Result
updater = builder.Update(group.Table)
)
updater = updater.Where(sql.InInts(group.FieldID, ids...))
if value := guo.name; value != nil {
updater.Set(group.FieldName, *value)
gr.Name = *value
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: *value,
Column: group.FieldName,
})
}
if !updater.Empty() {
query, args := updater.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
if nodes := guo.removedUsers; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: group.UsersTable,
Columns: group.UsersPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(guo.removedUsers) > 0 {
eids := make([]int, len(guo.removedUsers))
for eid := range guo.removedUsers {
eids = append(eids, eid)
if nodes := guo.users; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: group.UsersTable,
Columns: group.UsersPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
query, args := builder.Delete(group.UsersTable).
Where(sql.InInts(group.UsersPrimaryKey[0], ids...)).
Where(sql.InInts(group.UsersPrimaryKey[1], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
}
if len(guo.users) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range guo.users {
values = append(values, []int{id, eid})
}
}
builder := builder.Insert(group.UsersTable).
Columns(group.UsersPrimaryKey[0], group.UsersPrimaryKey[1])
for _, v := range values {
builder.Values(v[0], v[1])
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if guo.clearedAdmin {
query, args := builder.Update(group.AdminTable).
SetNull(group.AdminColumn).
Where(sql.InInts(user.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: false,
Table: group.AdminTable,
Columns: []string{group.AdminColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(guo.admin) > 0 {
for eid := range guo.admin {
query, args := builder.Update(group.AdminTable).
Set(group.AdminColumn, eid).
Where(sql.InInts(group.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
if nodes := guo.admin; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: false,
Table: group.AdminTable,
Columns: []string{group.AdminColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if err = tx.Commit(); err != nil {
gr = &Group{config: guo.config}
spec.ScanTypes = []interface{}{
&sql.NullInt64{},
&sql.NullString{},
}
spec.Assign = func(values ...interface{}) error {
if m, n := len(values), len(spec.ScanTypes); m != n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
value, ok := values[0].(*sql.NullInt64)
if !ok {
return fmt.Errorf("unexpected type %T for field id", value)
}
gr.ID = int(value.Int64)
values = values[1:]
if value, ok := values[0].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field name", values[0])
} else if value.Valid {
gr.Name = value.String
}
return nil
}
if err = sqlgraph.UpdateNode(ctx, guo.driver, spec); err != nil {
if cerr, ok := isSQLConstraintError(err); ok {
err = cerr
}
return nil, err
}
return gr, nil

382
examples/traversal/ent/pet_update.go
View File

@@ -12,9 +12,11 @@ import (
"fmt"
"github.com/facebookincubator/ent/dialect/sql"
"github.com/facebookincubator/ent/dialect/sql/sqlgraph"
"github.com/facebookincubator/ent/examples/traversal/ent/pet"
"github.com/facebookincubator/ent/examples/traversal/ent/predicate"
"github.com/facebookincubator/ent/examples/traversal/ent/user"
"github.com/facebookincubator/ent/schema/field"
)
// PetUpdate is the builder for updating Pet entities.
@@ -139,111 +141,110 @@ func (pu *PetUpdate) ExecX(ctx context.Context) {
}
func (pu *PetUpdate) sqlSave(ctx context.Context) (n int, err error) {
var (
builder = sql.Dialect(pu.driver.Dialect())
selector = builder.Select(pet.FieldID).From(builder.Table(pet.Table))
)
for _, p := range pu.predicates {
p(selector)
spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: pet.Table,
Columns: pet.Columns,
ID: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
rows := &sql.Rows{}
query, args := selector.Query()
if err = pu.driver.Query(ctx, query, args, rows); err != nil {
return 0, err
}
defer rows.Close()
var ids []int
for rows.Next() {
var id int
if err := rows.Scan(&id); err != nil {
return 0, fmt.Errorf("ent: failed reading id: %v", err)
}
ids = append(ids, id)
}
if len(ids) == 0 {
return 0, nil
}
tx, err := pu.driver.Tx(ctx)
if err != nil {
return 0, err
}
var (
res sql.Result
updater = builder.Update(pet.Table)
)
updater = updater.Where(sql.InInts(pet.FieldID, ids...))
if value := pu.name; value != nil {
updater.Set(pet.FieldName, *value)
}
if !updater.Empty() {
query, args := updater.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
}
if len(pu.removedFriends) > 0 {
eids := make([]int, len(pu.removedFriends))
for eid := range pu.removedFriends {
eids = append(eids, eid)
}
query, args := builder.Delete(pet.FriendsTable).
Where(sql.InInts(pet.FriendsPrimaryKey[0], ids...)).
Where(sql.InInts(pet.FriendsPrimaryKey[1], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
query, args = builder.Delete(pet.FriendsTable).
Where(sql.InInts(pet.FriendsPrimaryKey[1], ids...)).
Where(sql.InInts(pet.FriendsPrimaryKey[0], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
}
if len(pu.friends) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range pu.friends {
values = append(values, []int{id, eid}, []int{eid, id})
if ps := pu.predicates; len(ps) > 0 {
spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
builder := builder.Insert(pet.FriendsTable).
Columns(pet.FriendsPrimaryKey[0], pet.FriendsPrimaryKey[1])
for _, v := range values {
builder.Values(v[0], v[1])
}
if value := pu.name; value != nil {
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: *value,
Column: pet.FieldName,
})
}
if nodes := pu.removedFriends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: pet.FriendsTable,
Columns: pet.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if nodes := pu.friends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: pet.FriendsTable,
Columns: pet.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if pu.clearedOwner {
query, args := builder.Update(pet.OwnerTable).
SetNull(pet.OwnerColumn).
Where(sql.InInts(user.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: pet.OwnerTable,
Columns: []string{pet.OwnerColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(pu.owner) > 0 {
for eid := range pu.owner {
query, args := builder.Update(pet.OwnerTable).
Set(pet.OwnerColumn, eid).
Where(sql.InInts(pet.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
if nodes := pu.owner; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: pet.OwnerTable,
Columns: []string{pet.OwnerColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if err = tx.Commit(); err != nil {
if n, err = sqlgraph.UpdateNodes(ctx, pu.driver, spec); err != nil {
if cerr, ok := isSQLConstraintError(err); ok {
err = cerr
}
return 0, err
}
return len(ids), nil
return n, nil
}
// PetUpdateOne is the builder for updating a single Pet entity.
@@ -362,112 +363,123 @@ func (puo *PetUpdateOne) ExecX(ctx context.Context) {
}
func (puo *PetUpdateOne) sqlSave(ctx context.Context) (pe *Pet, err error) {
var (
builder = sql.Dialect(puo.driver.Dialect())
selector = builder.Select(pet.Columns...).From(builder.Table(pet.Table))
)
pet.ID(puo.id)(selector)
rows := &sql.Rows{}
query, args := selector.Query()
if err = puo.driver.Query(ctx, query, args, rows); err != nil {
return nil, err
spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: pet.Table,
Columns: pet.Columns,
ID: &sqlgraph.FieldSpec{
Value: puo.id,
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
defer rows.Close()
var ids []int
for rows.Next() {
var id int
pe = &Pet{config: puo.config}
if err := pe.FromRows(rows); err != nil {
return nil, fmt.Errorf("ent: failed scanning row into Pet: %v", err)
}
id = pe.ID
ids = append(ids, id)
}
switch n := len(ids); {
case n == 0:
return nil, &ErrNotFound{fmt.Sprintf("Pet with id: %v", puo.id)}
case n > 1:
return nil, fmt.Errorf("ent: more than one Pet with the same id: %v", puo.id)
}
tx, err := puo.driver.Tx(ctx)
if err != nil {
return nil, err
}
var (
res sql.Result
updater = builder.Update(pet.Table)
)
updater = updater.Where(sql.InInts(pet.FieldID, ids...))
if value := puo.name; value != nil {
updater.Set(pet.FieldName, *value)
pe.Name = *value
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: *value,
Column: pet.FieldName,
})
}
if !updater.Empty() {
query, args := updater.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
if nodes := puo.removedFriends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: pet.FriendsTable,
Columns: pet.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(puo.removedFriends) > 0 {
eids := make([]int, len(puo.removedFriends))
for eid := range puo.removedFriends {
eids = append(eids, eid)
if nodes := puo.friends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: pet.FriendsTable,
Columns: pet.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
query, args := builder.Delete(pet.FriendsTable).
Where(sql.InInts(pet.FriendsPrimaryKey[0], ids...)).
Where(sql.InInts(pet.FriendsPrimaryKey[1], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
query, args = builder.Delete(pet.FriendsTable).
Where(sql.InInts(pet.FriendsPrimaryKey[1], ids...)).
Where(sql.InInts(pet.FriendsPrimaryKey[0], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
}
if len(puo.friends) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range puo.friends {
values = append(values, []int{id, eid}, []int{eid, id})
}
}
builder := builder.Insert(pet.FriendsTable).
Columns(pet.FriendsPrimaryKey[0], pet.FriendsPrimaryKey[1])
for _, v := range values {
builder.Values(v[0], v[1])
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if puo.clearedOwner {
query, args := builder.Update(pet.OwnerTable).
SetNull(pet.OwnerColumn).
Where(sql.InInts(user.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: pet.OwnerTable,
Columns: []string{pet.OwnerColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(puo.owner) > 0 {
for eid := range puo.owner {
query, args := builder.Update(pet.OwnerTable).
Set(pet.OwnerColumn, eid).
Where(sql.InInts(pet.FieldID, ids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
if nodes := puo.owner; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2O,
Inverse: true,
Table: pet.OwnerTable,
Columns: []string{pet.OwnerColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if err = tx.Commit(); err != nil {
pe = &Pet{config: puo.config}
spec.ScanTypes = []interface{}{
&sql.NullInt64{},
&sql.NullString{},
}
spec.Assign = func(values ...interface{}) error {
if m, n := len(values), len(spec.ScanTypes); m != n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
value, ok := values[0].(*sql.NullInt64)
if !ok {
return fmt.Errorf("unexpected type %T for field id", value)
}
pe.ID = int(value.Int64)
values = values[1:]
if value, ok := values[0].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field name", values[0])
} else if value.Valid {
pe.Name = value.String
}
return nil
}
if err = sqlgraph.UpdateNode(ctx, puo.driver, spec); err != nil {
if cerr, ok := isSQLConstraintError(err); ok {
err = cerr
}
return nil, err
}
return pe, nil

676
examples/traversal/ent/user_update.go
View File

@@ -11,10 +11,12 @@ import (
"fmt"
"github.com/facebookincubator/ent/dialect/sql"
"github.com/facebookincubator/ent/dialect/sql/sqlgraph"
"github.com/facebookincubator/ent/examples/traversal/ent/group"
"github.com/facebookincubator/ent/examples/traversal/ent/pet"
"github.com/facebookincubator/ent/examples/traversal/ent/predicate"
"github.com/facebookincubator/ent/examples/traversal/ent/user"
"github.com/facebookincubator/ent/schema/field"
)
// UserUpdate is the builder for updating User entities.
@@ -251,199 +253,203 @@ func (uu *UserUpdate) ExecX(ctx context.Context) {
}
func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
var (
builder = sql.Dialect(uu.driver.Dialect())
selector = builder.Select(user.FieldID).From(builder.Table(user.Table))
)
for _, p := range uu.predicates {
p(selector)
spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: user.Table,
Columns: user.Columns,
ID: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
rows := &sql.Rows{}
query, args := selector.Query()
if err = uu.driver.Query(ctx, query, args, rows); err != nil {
return 0, err
}
defer rows.Close()
var ids []int
for rows.Next() {
var id int
if err := rows.Scan(&id); err != nil {
return 0, fmt.Errorf("ent: failed reading id: %v", err)
if ps := uu.predicates; len(ps) > 0 {
spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
ids = append(ids, id)
}
if len(ids) == 0 {
return 0, nil
}
tx, err := uu.driver.Tx(ctx)
if err != nil {
return 0, err
}
var (
res sql.Result
updater = builder.Update(user.Table)
)
updater = updater.Where(sql.InInts(user.FieldID, ids...))
if value := uu.age; value != nil {
updater.Set(user.FieldAge, *value)
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: *value,
Column: user.FieldAge,
})
}
if value := uu.addage; value != nil {
updater.Add(user.FieldAge, *value)
spec.Fields.Add = append(spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: *value,
Column: user.FieldAge,
})
}
if value := uu.name; value != nil {
updater.Set(user.FieldName, *value)
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: *value,
Column: user.FieldName,
})
}
if !updater.Empty() {
query, args := updater.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
if nodes := uu.removedPets; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.PetsTable,
Columns: []string{user.PetsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uu.removedPets) > 0 {
eids := make([]int, len(uu.removedPets))
for eid := range uu.removedPets {
eids = append(eids, eid)
if nodes := uu.pets; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.PetsTable,
Columns: []string{user.PetsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
query, args := builder.Update(user.PetsTable).
SetNull(user.PetsColumn).
Where(sql.InInts(user.PetsColumn, ids...)).
Where(sql.InInts(pet.FieldID, eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uu.pets) > 0 {
for _, id := range ids {
p := sql.P()
for eid := range uu.pets {
p.Or().EQ(pet.FieldID, eid)
}
query, args := builder.Update(user.PetsTable).
Set(user.PetsColumn, id).
Where(sql.And(p, sql.IsNull(user.PetsColumn))).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
affected, err := res.RowsAffected()
if err != nil {
return 0, rollback(tx, err)
}
if int(affected) < len(uu.pets) {
return 0, rollback(tx, &ConstraintError{msg: fmt.Sprintf("one of \"pets\" %v already connected to a different \"User\"", keys(uu.pets))})
}
if nodes := uu.removedFriends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: user.FriendsTable,
Columns: user.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uu.removedFriends) > 0 {
eids := make([]int, len(uu.removedFriends))
for eid := range uu.removedFriends {
eids = append(eids, eid)
if nodes := uu.friends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: user.FriendsTable,
Columns: user.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
query, args := builder.Delete(user.FriendsTable).
Where(sql.InInts(user.FriendsPrimaryKey[0], ids...)).
Where(sql.InInts(user.FriendsPrimaryKey[1], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
query, args = builder.Delete(user.FriendsTable).
Where(sql.InInts(user.FriendsPrimaryKey[1], ids...)).
Where(sql.InInts(user.FriendsPrimaryKey[0], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uu.friends) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range uu.friends {
values = append(values, []int{id, eid}, []int{eid, id})
}
if nodes := uu.removedGroups; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: true,
Table: user.GroupsTable,
Columns: user.GroupsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
builder := builder.Insert(user.FriendsTable).
Columns(user.FriendsPrimaryKey[0], user.FriendsPrimaryKey[1])
for _, v := range values {
builder.Values(v[0], v[1])
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uu.removedGroups) > 0 {
eids := make([]int, len(uu.removedGroups))
for eid := range uu.removedGroups {
eids = append(eids, eid)
if nodes := uu.groups; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: true,
Table: user.GroupsTable,
Columns: user.GroupsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
query, args := builder.Delete(user.GroupsTable).
Where(sql.InInts(user.GroupsPrimaryKey[1], ids...)).
Where(sql.InInts(user.GroupsPrimaryKey[0], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uu.groups) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range uu.groups {
values = append(values, []int{id, eid})
}
if nodes := uu.removedManage; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: true,
Table: user.ManageTable,
Columns: []string{user.ManageColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
builder := builder.Insert(user.GroupsTable).
Columns(user.GroupsPrimaryKey[1], user.GroupsPrimaryKey[0])
for _, v := range values {
builder.Values(v[0], v[1])
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uu.removedManage) > 0 {
eids := make([]int, len(uu.removedManage))
for eid := range uu.removedManage {
eids = append(eids, eid)
if nodes := uu.manage; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: true,
Table: user.ManageTable,
Columns: []string{user.ManageColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
query, args := builder.Update(user.ManageTable).
SetNull(user.ManageColumn).
Where(sql.InInts(user.ManageColumn, ids...)).
Where(sql.InInts(group.FieldID, eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uu.manage) > 0 {
for _, id := range ids {
p := sql.P()
for eid := range uu.manage {
p.Or().EQ(group.FieldID, eid)
}
query, args := builder.Update(user.ManageTable).
Set(user.ManageColumn, id).
Where(sql.And(p, sql.IsNull(user.ManageColumn))).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return 0, rollback(tx, err)
}
affected, err := res.RowsAffected()
if err != nil {
return 0, rollback(tx, err)
}
if int(affected) < len(uu.manage) {
return 0, rollback(tx, &ConstraintError{msg: fmt.Sprintf("one of \"manage\" %v already connected to a different \"User\"", keys(uu.manage))})
}
if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, spec); err != nil {
if cerr, ok := isSQLConstraintError(err); ok {
err = cerr
}
}
if err = tx.Commit(); err != nil {
return 0, err
}
return len(ids), nil
return n, nil
}
// UserUpdateOne is the builder for updating a single User entity.
@@ -674,202 +680,222 @@ func (uuo *UserUpdateOne) ExecX(ctx context.Context) {
}
func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (u *User, err error) {
var (
builder = sql.Dialect(uuo.driver.Dialect())
selector = builder.Select(user.Columns...).From(builder.Table(user.Table))
)
user.ID(uuo.id)(selector)
rows := &sql.Rows{}
query, args := selector.Query()
if err = uuo.driver.Query(ctx, query, args, rows); err != nil {
return nil, err
spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: user.Table,
Columns: user.Columns,
ID: &sqlgraph.FieldSpec{
Value: uuo.id,
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
defer rows.Close()
var ids []int
for rows.Next() {
var id int
u = &User{config: uuo.config}
if err := u.FromRows(rows); err != nil {
return nil, fmt.Errorf("ent: failed scanning row into User: %v", err)
}
id = u.ID
ids = append(ids, id)
}
switch n := len(ids); {
case n == 0:
return nil, &ErrNotFound{fmt.Sprintf("User with id: %v", uuo.id)}
case n > 1:
return nil, fmt.Errorf("ent: more than one User with the same id: %v", uuo.id)
}
tx, err := uuo.driver.Tx(ctx)
if err != nil {
return nil, err
}
var (
res sql.Result
updater = builder.Update(user.Table)
)
updater = updater.Where(sql.InInts(user.FieldID, ids...))
if value := uuo.age; value != nil {
updater.Set(user.FieldAge, *value)
u.Age = *value
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: *value,
Column: user.FieldAge,
})
}
if value := uuo.addage; value != nil {
updater.Add(user.FieldAge, *value)
u.Age += *value
spec.Fields.Add = append(spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: *value,
Column: user.FieldAge,
})
}
if value := uuo.name; value != nil {
updater.Set(user.FieldName, *value)
u.Name = *value
spec.Fields.Set = append(spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: *value,
Column: user.FieldName,
})
}
if !updater.Empty() {
query, args := updater.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
if nodes := uuo.removedPets; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.PetsTable,
Columns: []string{user.PetsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uuo.removedPets) > 0 {
eids := make([]int, len(uuo.removedPets))
for eid := range uuo.removedPets {
eids = append(eids, eid)
if nodes := uuo.pets; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: false,
Table: user.PetsTable,
Columns: []string{user.PetsColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: pet.FieldID,
},
},
}
query, args := builder.Update(user.PetsTable).
SetNull(user.PetsColumn).
Where(sql.InInts(user.PetsColumn, ids...)).
Where(sql.InInts(pet.FieldID, eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uuo.pets) > 0 {
for _, id := range ids {
p := sql.P()
for eid := range uuo.pets {
p.Or().EQ(pet.FieldID, eid)
}
query, args := builder.Update(user.PetsTable).
Set(user.PetsColumn, id).
Where(sql.And(p, sql.IsNull(user.PetsColumn))).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
affected, err := res.RowsAffected()
if err != nil {
return nil, rollback(tx, err)
}
if int(affected) < len(uuo.pets) {
return nil, rollback(tx, &ConstraintError{msg: fmt.Sprintf("one of \"pets\" %v already connected to a different \"User\"", keys(uuo.pets))})
}
if nodes := uuo.removedFriends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: user.FriendsTable,
Columns: user.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uuo.removedFriends) > 0 {
eids := make([]int, len(uuo.removedFriends))
for eid := range uuo.removedFriends {
eids = append(eids, eid)
if nodes := uuo.friends; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: false,
Table: user.FriendsTable,
Columns: user.FriendsPrimaryKey,
Bidi: true,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: user.FieldID,
},
},
}
query, args := builder.Delete(user.FriendsTable).
Where(sql.InInts(user.FriendsPrimaryKey[0], ids...)).
Where(sql.InInts(user.FriendsPrimaryKey[1], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
query, args = builder.Delete(user.FriendsTable).
Where(sql.InInts(user.FriendsPrimaryKey[1], ids...)).
Where(sql.InInts(user.FriendsPrimaryKey[0], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uuo.friends) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range uuo.friends {
values = append(values, []int{id, eid}, []int{eid, id})
}
if nodes := uuo.removedGroups; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: true,
Table: user.GroupsTable,
Columns: user.GroupsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
builder := builder.Insert(user.FriendsTable).
Columns(user.FriendsPrimaryKey[0], user.FriendsPrimaryKey[1])
for _, v := range values {
builder.Values(v[0], v[1])
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uuo.removedGroups) > 0 {
eids := make([]int, len(uuo.removedGroups))
for eid := range uuo.removedGroups {
eids = append(eids, eid)
if nodes := uuo.groups; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.M2M,
Inverse: true,
Table: user.GroupsTable,
Columns: user.GroupsPrimaryKey,
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
query, args := builder.Delete(user.GroupsTable).
Where(sql.InInts(user.GroupsPrimaryKey[1], ids...)).
Where(sql.InInts(user.GroupsPrimaryKey[0], eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uuo.groups) > 0 {
values := make([][]int, 0, len(ids))
for _, id := range ids {
for eid := range uuo.groups {
values = append(values, []int{id, eid})
}
if nodes := uuo.removedManage; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: true,
Table: user.ManageTable,
Columns: []string{user.ManageColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
builder := builder.Insert(user.GroupsTable).
Columns(user.GroupsPrimaryKey[1], user.GroupsPrimaryKey[0])
for _, v := range values {
builder.Values(v[0], v[1])
}
query, args := builder.Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Clear = append(spec.Edges.Clear, edge)
}
if len(uuo.removedManage) > 0 {
eids := make([]int, len(uuo.removedManage))
for eid := range uuo.removedManage {
eids = append(eids, eid)
if nodes := uuo.manage; len(nodes) > 0 {
edge := &sqlgraph.EdgeSpec{
Rel: sqlgraph.O2M,
Inverse: true,
Table: user.ManageTable,
Columns: []string{user.ManageColumn},
Bidi: false,
Target: &sqlgraph.EdgeTarget{
IDSpec: &sqlgraph.FieldSpec{
Type: field.TypeInt,
Column: group.FieldID,
},
},
}
query, args := builder.Update(user.ManageTable).
SetNull(user.ManageColumn).
Where(sql.InInts(user.ManageColumn, ids...)).
Where(sql.InInts(group.FieldID, eids...)).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
for k, _ := range nodes {
edge.Target.Nodes = append(edge.Target.Nodes, k)
}
spec.Edges.Add = append(spec.Edges.Add, edge)
}
if len(uuo.manage) > 0 {
for _, id := range ids {
p := sql.P()
for eid := range uuo.manage {
p.Or().EQ(group.FieldID, eid)
}
query, args := builder.Update(user.ManageTable).
Set(user.ManageColumn, id).
Where(sql.And(p, sql.IsNull(user.ManageColumn))).
Query()
if err := tx.Exec(ctx, query, args, &res); err != nil {
return nil, rollback(tx, err)
}
affected, err := res.RowsAffected()
if err != nil {
return nil, rollback(tx, err)
}
if int(affected) < len(uuo.manage) {
return nil, rollback(tx, &ConstraintError{msg: fmt.Sprintf("one of \"manage\" %v already connected to a different \"User\"", keys(uuo.manage))})
}
}
u = &User{config: uuo.config}
spec.ScanTypes = []interface{}{
&sql.NullInt64{},
&sql.NullInt64{},
&sql.NullString{},
}
if err = tx.Commit(); err != nil {
spec.Assign = func(values ...interface{}) error {
if m, n := len(values), len(spec.ScanTypes); m != n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
value, ok := values[0].(*sql.NullInt64)
if !ok {
return fmt.Errorf("unexpected type %T for field id", value)
}
u.ID = int(value.Int64)
values = values[1:]
if value, ok := values[0].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field age", values[0])
} else if value.Valid {
u.Age = int(value.Int64)
}
if value, ok := values[1].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field name", values[1])
} else if value.Valid {
u.Name = value.String
}
return nil
}
if err = sqlgraph.UpdateNode(ctx, uuo.driver, spec); err != nil {
if cerr, ok := isSQLConstraintError(err); ok {
err = cerr
}
return nil, err
}
return u, nil