From dc8ea50747ef7c797d5c48227d888cd5e7f12fba Mon Sep 17 00:00:00 2001 From: Ariel Mashraki <7413593+a8m@users.noreply.github.com> Date: Wed, 16 Aug 2023 11:46:14 +0300 Subject: [PATCH] entc/gen: add support for MapBulkCreate (#3696) --- doc/md/crud.mdx | 16 +- .../blog/2023-08-13-visualize-with-atlas.md | 2 +- entc/gen/template/builder/create.tmpl | 1 + entc/gen/template/client.tmpl | 16 + entc/gen/template/dialect/sql/create.tmpl | 4 + .../template/dialect/sql/feature/upsert.tmpl | 3 + entc/integration/cascadelete/ent/client.go | 46 +++ .../cascadelete/ent/comment_create.go | 4 + .../cascadelete/ent/post_create.go | 4 + .../cascadelete/ent/user_create.go | 4 + entc/integration/config/ent/client.go | 16 + entc/integration/config/ent/user_create.go | 4 + .../customid/ent/account_create.go | 7 + entc/integration/customid/ent/blob_create.go | 7 + .../customid/ent/bloblink_create.go | 7 + entc/integration/customid/ent/car_create.go | 7 + entc/integration/customid/ent/client.go | 256 ++++++++++++++++ .../integration/customid/ent/device_create.go | 7 + entc/integration/customid/ent/doc_create.go | 7 + entc/integration/customid/ent/group_create.go | 7 + .../integration/customid/ent/intsid_create.go | 7 + entc/integration/customid/ent/link_create.go | 7 + .../customid/ent/mixinid_create.go | 7 + entc/integration/customid/ent/note_create.go | 7 + entc/integration/customid/ent/other_create.go | 7 + entc/integration/customid/ent/pet_create.go | 7 + .../customid/ent/revision_create.go | 7 + .../customid/ent/session_create.go | 7 + entc/integration/customid/ent/token_create.go | 7 + entc/integration/customid/ent/user_create.go | 7 + entc/integration/edgefield/ent/car_create.go | 4 + entc/integration/edgefield/ent/card_create.go | 4 + entc/integration/edgefield/ent/client.go | 136 +++++++++ entc/integration/edgefield/ent/info_create.go | 4 + .../edgefield/ent/metadata_create.go | 4 + entc/integration/edgefield/ent/node_create.go | 4 + entc/integration/edgefield/ent/pet_create.go | 4 + entc/integration/edgefield/ent/post_create.go | 4 + .../edgefield/ent/rental_create.go | 4 + entc/integration/edgefield/ent/user_create.go | 4 + .../edgeschema/ent/attachedfile_create.go | 7 + entc/integration/edgeschema/ent/client.go | 256 ++++++++++++++++ .../integration/edgeschema/ent/file_create.go | 7 + .../edgeschema/ent/friendship_create.go | 7 + .../edgeschema/ent/group_create.go | 7 + .../edgeschema/ent/grouptag_create.go | 7 + .../edgeschema/ent/process_create.go | 7 + .../edgeschema/ent/relationship_create.go | 7 + .../edgeschema/ent/relationshipinfo_create.go | 7 + .../integration/edgeschema/ent/role_create.go | 7 + .../edgeschema/ent/roleuser_create.go | 7 + entc/integration/edgeschema/ent/tag_create.go | 7 + .../edgeschema/ent/tweet_create.go | 7 + .../edgeschema/ent/tweetlike_create.go | 7 + .../edgeschema/ent/tweettag_create.go | 7 + .../integration/edgeschema/ent/user_create.go | 7 + .../edgeschema/ent/usergroup_create.go | 7 + .../edgeschema/ent/usertweet_create.go | 7 + entc/integration/ent/api_create.go | 7 + entc/integration/ent/builder_create.go | 7 + entc/integration/ent/card_create.go | 7 + entc/integration/ent/client.go | 286 ++++++++++++++++++ entc/integration/ent/comment_create.go | 7 + entc/integration/ent/exvaluescan_create.go | 7 + entc/integration/ent/fieldtype_create.go | 7 + entc/integration/ent/file_create.go | 7 + entc/integration/ent/filetype_create.go | 7 + entc/integration/ent/goods_create.go | 7 + entc/integration/ent/group_create.go | 7 + entc/integration/ent/groupinfo_create.go | 7 + entc/integration/ent/item_create.go | 7 + entc/integration/ent/license_create.go | 7 + entc/integration/ent/node_create.go | 7 + entc/integration/ent/pc_create.go | 7 + entc/integration/ent/pet_create.go | 7 + entc/integration/ent/spec_create.go | 7 + entc/integration/ent/task_create.go | 7 + entc/integration/ent/user_create.go | 7 + entc/integration/gremlin/ent/api_create.go | 1 + .../integration/gremlin/ent/builder_create.go | 1 + entc/integration/gremlin/ent/card_create.go | 1 + entc/integration/gremlin/ent/client.go | 286 ++++++++++++++++++ .../integration/gremlin/ent/comment_create.go | 1 + .../gremlin/ent/exvaluescan_create.go | 1 + .../gremlin/ent/fieldtype_create.go | 1 + entc/integration/gremlin/ent/file_create.go | 1 + .../gremlin/ent/filetype_create.go | 1 + entc/integration/gremlin/ent/goods_create.go | 1 + entc/integration/gremlin/ent/group_create.go | 1 + .../gremlin/ent/groupinfo_create.go | 1 + entc/integration/gremlin/ent/item_create.go | 1 + .../integration/gremlin/ent/license_create.go | 1 + entc/integration/gremlin/ent/node_create.go | 1 + entc/integration/gremlin/ent/pc_create.go | 1 + entc/integration/gremlin/ent/pet_create.go | 1 + entc/integration/gremlin/ent/spec_create.go | 1 + entc/integration/gremlin/ent/task_create.go | 1 + entc/integration/gremlin/ent/user_create.go | 1 + entc/integration/hooks/ent/card_create.go | 4 + entc/integration/hooks/ent/client.go | 46 +++ entc/integration/hooks/ent/pet_create.go | 4 + entc/integration/hooks/ent/user_create.go | 4 + entc/integration/idtype/ent/client.go | 16 + entc/integration/idtype/ent/user_create.go | 4 + entc/integration/integration_test.go | 11 +- entc/integration/json/ent/client.go | 16 + entc/integration/json/ent/user_create.go | 4 + entc/integration/migrate/entv1/car_create.go | 4 + entc/integration/migrate/entv1/client.go | 61 ++++ .../migrate/entv1/conversion_create.go | 4 + .../migrate/entv1/customtype_create.go | 4 + entc/integration/migrate/entv1/user_create.go | 4 + entc/integration/migrate/entv2/blog_create.go | 4 + entc/integration/migrate/entv2/car_create.go | 4 + entc/integration/migrate/entv2/client.go | 136 +++++++++ .../migrate/entv2/conversion_create.go | 4 + .../migrate/entv2/customtype_create.go | 4 + .../integration/migrate/entv2/group_create.go | 4 + .../integration/migrate/entv2/media_create.go | 4 + entc/integration/migrate/entv2/pet_create.go | 4 + entc/integration/migrate/entv2/user_create.go | 4 + entc/integration/migrate/entv2/zoo_create.go | 4 + entc/integration/migrate/versioned/client.go | 31 ++ .../migrate/versioned/group_create.go | 4 + .../migrate/versioned/user_create.go | 4 + entc/integration/multischema/ent/client.go | 61 ++++ .../multischema/ent/friendship_create.go | 4 + .../multischema/ent/group_create.go | 4 + .../integration/multischema/ent/pet_create.go | 4 + .../multischema/ent/user_create.go | 4 + entc/integration/privacy/ent/client.go | 46 +++ entc/integration/privacy/ent/task_create.go | 4 + entc/integration/privacy/ent/team_create.go | 4 + entc/integration/privacy/ent/user_create.go | 4 + entc/integration/template/ent/client.go | 46 +++ entc/integration/template/ent/group_create.go | 4 + entc/integration/template/ent/pet_create.go | 4 + entc/integration/template/ent/user_create.go | 4 + examples/edgeindex/ent/city_create.go | 4 + examples/edgeindex/ent/client.go | 31 ++ examples/edgeindex/ent/street_create.go | 4 + examples/encryptfield/ent/client.go | 16 + examples/encryptfield/ent/user_create.go | 4 + examples/entcpkg/ent/client.go | 16 + examples/entcpkg/ent/user_create.go | 4 + examples/fs/ent/client.go | 16 + examples/fs/ent/file_create.go | 4 + examples/jsonencode/ent/card_create.go | 4 + examples/jsonencode/ent/client.go | 46 +++ examples/jsonencode/ent/pet_create.go | 4 + examples/jsonencode/ent/user_create.go | 4 + examples/m2m2types/ent/client.go | 31 ++ examples/m2m2types/ent/group_create.go | 4 + examples/m2m2types/ent/user_create.go | 4 + examples/m2mbidi/ent/client.go | 16 + examples/m2mbidi/ent/user_create.go | 4 + examples/m2mrecur/ent/client.go | 16 + examples/m2mrecur/ent/user_create.go | 4 + examples/migration/ent/card_create.go | 4 + examples/migration/ent/client.go | 46 +++ examples/migration/ent/pet_create.go | 4 + examples/migration/ent/user_create.go | 4 + examples/o2m2types/ent/client.go | 31 ++ examples/o2m2types/ent/pet_create.go | 4 + examples/o2m2types/ent/user_create.go | 4 + examples/o2mrecur/ent/client.go | 16 + examples/o2mrecur/ent/node_create.go | 4 + examples/o2o2types/ent/card_create.go | 4 + examples/o2o2types/ent/client.go | 31 ++ examples/o2o2types/ent/user_create.go | 4 + examples/o2obidi/ent/client.go | 16 + examples/o2obidi/ent/user_create.go | 4 + examples/o2orecur/ent/client.go | 16 + examples/o2orecur/ent/node_create.go | 4 + examples/privacyadmin/ent/client.go | 16 + examples/privacyadmin/ent/user_create.go | 4 + examples/privacytenant/ent/client.go | 46 +++ examples/privacytenant/ent/group_create.go | 4 + examples/privacytenant/ent/tenant_create.go | 4 + examples/privacytenant/ent/user_create.go | 4 + examples/start/ent/car_create.go | 4 + examples/start/ent/client.go | 46 +++ examples/start/ent/group_create.go | 4 + examples/start/ent/user_create.go | 4 + examples/traversal/ent/client.go | 46 +++ examples/traversal/ent/group_create.go | 4 + examples/traversal/ent/pet_create.go | 4 + examples/traversal/ent/user_create.go | 4 + examples/version/ent/client.go | 16 + examples/version/ent/user_create.go | 4 + 190 files changed, 2991 insertions(+), 11 deletions(-) diff --git a/doc/md/crud.mdx b/doc/md/crud.mdx index 447673922..a05803481 100644 --- a/doc/md/crud.mdx +++ b/doc/md/crud.mdx @@ -159,13 +159,17 @@ pedro := client.Pet. // PetClient. **Save** a bulk of pets. -```go +```go {1,8} +pets, err := client.Pet.CreateBulk( + client.Pet.Create().SetName("pedro").SetOwner(a8m), + client.Pet.Create().SetName("xabi").SetOwner(a8m), + client.Pet.Create().SetName("layla").SetOwner(a8m), +).Save(ctx) + names := []string{"pedro", "xabi", "layla"} -bulk := make([]*ent.PetCreate, len(names)) -for i, name := range names { - bulk[i] = client.Pet.Create().SetName(name).SetOwner(a8m) -} -pets, err := client.Pet.CreateBulk(bulk...).Save(ctx) +pets, err := client.Pet.MapCreateBulk(names, func(c *ent.PetCreate, i int) { + client.Pet.Create().SetName(names[i]).SetOwner(a8m) +}).Save(ctx) ``` ## Update One diff --git a/doc/website/blog/2023-08-13-visualize-with-atlas.md b/doc/website/blog/2023-08-13-visualize-with-atlas.md index e485377bf..0f5718904 100644 --- a/doc/website/blog/2023-08-13-visualize-with-atlas.md +++ b/doc/website/blog/2023-08-13-visualize-with-atlas.md @@ -37,7 +37,7 @@ additional tool. Previously, you could only share a visualization of your schema to the [Atlas Public Playground](https://gh.atlasgo.cloud/explore). While this is convenient for sharing your schema with others, it is not acceptable for many teams who maintain -schemas that themselves are senstive and cannot be shared publicly. +schemas that themselves are sensitive and cannot be shared publicly. With this new release, you can easily publish your schema directly to your private workspace on [Atlas Cloud](https://atlasgo.cloud). This means that only you and your diff --git a/entc/gen/template/builder/create.tmpl b/entc/gen/template/builder/create.tmpl index 0101a6721..3a3d2eac3 100644 --- a/entc/gen/template/builder/create.tmpl +++ b/entc/gen/template/builder/create.tmpl @@ -157,6 +157,7 @@ func ({{ $receiver }} *{{ $builder }}) check() error { // {{ $bulk }} is the builder for creating many {{ $.Name }} entities in bulk. type {{ $bulk }} struct { config + err error builders []*{{ $builder }} {{- /* Additional fields to add to the builder. */}} {{- $tmpl = printf "dialect/%s/create_bulk/fields" $.Storage }} diff --git a/entc/gen/template/client.tmpl b/entc/gen/template/client.tmpl index 9ce9a4c70..7d0d4d780 100644 --- a/entc/gen/template/client.tmpl +++ b/entc/gen/template/client.tmpl @@ -303,6 +303,22 @@ func (c *{{ $client }}) CreateBulk(builders ...*{{ $n.CreateName }}) *{{ $n.Crea return &{{ $n.CreateBulkName }}{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *{{ $client }}) MapCreateBulk(slice any, setFunc func(*{{ $n.CreateName }}, int)) *{{ $n.CreateBulkName }} { + {{- /* This check should be replaced with type-parameter method, if it will be supported by Go. */}} + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &{{ $n.CreateBulkName }}{err: fmt.Errorf("calling to {{ $client }}.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*{{ $n.CreateName }}, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &{{ $n.CreateBulkName }}{config: c.config, builders: builders} +} + // Update returns an update builder for {{ $n.Name }}. func (c *{{ $client }}) Update() *{{ $n.UpdateName }} { mutation := new{{ $n.MutationName }}(c.config, OpUpdate) diff --git a/entc/gen/template/dialect/sql/create.tmpl b/entc/gen/template/dialect/sql/create.tmpl index 024141d81..3f871e44a 100644 --- a/entc/gen/template/dialect/sql/create.tmpl +++ b/entc/gen/template/dialect/sql/create.tmpl @@ -143,6 +143,10 @@ func ({{ $receiver }} *{{ $builder }}) createSpec() (*{{ $.Name }}, *sqlgraph.Cr // Save creates the {{ $.Name }} entities in the database. func ({{ $receiver }} *{{ $builder }}) Save(ctx context.Context) ([]*{{ $.Name }}, error) { + {{- /* Initialization error was set by MapCreateBulk. */}} + if {{ $receiver }}.err != nil { + return nil, {{ $receiver }}.err + } specs := make([]*sqlgraph.CreateSpec, len({{ $receiver }}.builders)) nodes := make([]*{{ $.Name }}, len({{ $receiver }}.builders)) mutators := make([]Mutator, len({{ $receiver }}.builders)) diff --git a/entc/gen/template/dialect/sql/feature/upsert.tmpl b/entc/gen/template/dialect/sql/feature/upsert.tmpl index 80c8799ea..896080738 100644 --- a/entc/gen/template/dialect/sql/feature/upsert.tmpl +++ b/entc/gen/template/dialect/sql/feature/upsert.tmpl @@ -385,6 +385,9 @@ func (u *{{ $upsertBulk }}) Update(set func(*{{ $upsertSet }})) *{{ $upsertBulk // Exec executes the query. func (u *{{ $upsertBulk }}) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("{{ $pkg }}: OnConflict was set for builder %d. Set it on the {{ $builder }} instead", i) diff --git a/entc/integration/cascadelete/ent/client.go b/entc/integration/cascadelete/ent/client.go index afea58397..94c0e58cc 100644 --- a/entc/integration/cascadelete/ent/client.go +++ b/entc/integration/cascadelete/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/cascadelete/ent/migrate" @@ -248,6 +249,21 @@ func (c *CommentClient) CreateBulk(builders ...*CommentCreate) *CommentCreateBul return &CommentCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CommentClient) MapCreateBulk(slice any, setFunc func(*CommentCreate, int)) *CommentCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CommentCreateBulk{err: fmt.Errorf("calling to CommentClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CommentCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CommentCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Comment. func (c *CommentClient) Update() *CommentUpdate { mutation := newCommentMutation(c.config, OpUpdate) @@ -382,6 +398,21 @@ func (c *PostClient) CreateBulk(builders ...*PostCreate) *PostCreateBulk { return &PostCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PostClient) MapCreateBulk(slice any, setFunc func(*PostCreate, int)) *PostCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PostCreateBulk{err: fmt.Errorf("calling to PostClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PostCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PostCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Post. func (c *PostClient) Update() *PostUpdate { mutation := newPostMutation(c.config, OpUpdate) @@ -532,6 +563,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/cascadelete/ent/comment_create.go b/entc/integration/cascadelete/ent/comment_create.go index 3a349a583..a0ff1b87b 100644 --- a/entc/integration/cascadelete/ent/comment_create.go +++ b/entc/integration/cascadelete/ent/comment_create.go @@ -137,11 +137,15 @@ func (cc *CommentCreate) createSpec() (*Comment, *sqlgraph.CreateSpec) { // CommentCreateBulk is the builder for creating many Comment entities in bulk. type CommentCreateBulk struct { config + err error builders []*CommentCreate } // Save creates the Comment entities in the database. func (ccb *CommentCreateBulk) Save(ctx context.Context) ([]*Comment, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Comment, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/cascadelete/ent/post_create.go b/entc/integration/cascadelete/ent/post_create.go index bdb179be0..d2e5f22f0 100644 --- a/entc/integration/cascadelete/ent/post_create.go +++ b/entc/integration/cascadelete/ent/post_create.go @@ -188,11 +188,15 @@ func (pc *PostCreate) createSpec() (*Post, *sqlgraph.CreateSpec) { // PostCreateBulk is the builder for creating many Post entities in bulk. type PostCreateBulk struct { config + err error builders []*PostCreate } // Save creates the Post entities in the database. func (pcb *PostCreateBulk) Save(ctx context.Context) ([]*Post, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Post, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/cascadelete/ent/user_create.go b/entc/integration/cascadelete/ent/user_create.go index 423da683c..d56207a65 100644 --- a/entc/integration/cascadelete/ent/user_create.go +++ b/entc/integration/cascadelete/ent/user_create.go @@ -151,11 +151,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/config/ent/client.go b/entc/integration/config/ent/client.go index 117f23aef..a24d494f4 100644 --- a/entc/integration/config/ent/client.go +++ b/entc/integration/config/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/config/ent/migrate" @@ -227,6 +228,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/config/ent/user_create.go b/entc/integration/config/ent/user_create.go index 8e61b835a..9d0236d13 100644 --- a/entc/integration/config/ent/user_create.go +++ b/entc/integration/config/ent/user_create.go @@ -136,11 +136,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/customid/ent/account_create.go b/entc/integration/customid/ent/account_create.go index 9de8b0524..c1b630dd0 100644 --- a/entc/integration/customid/ent/account_create.go +++ b/entc/integration/customid/ent/account_create.go @@ -337,12 +337,16 @@ func (u *AccountUpsertOne) IDX(ctx context.Context) sid.ID { // AccountCreateBulk is the builder for creating many Account entities in bulk. type AccountCreateBulk struct { config + err error builders []*AccountCreate conflict []sql.ConflictOption } // Save creates the Account entities in the database. func (acb *AccountCreateBulk) Save(ctx context.Context) ([]*Account, error) { + if acb.err != nil { + return nil, acb.err + } specs := make([]*sqlgraph.CreateSpec, len(acb.builders)) nodes := make([]*Account, len(acb.builders)) mutators := make([]Mutator, len(acb.builders)) @@ -523,6 +527,9 @@ func (u *AccountUpsertBulk) UpdateEmail() *AccountUpsertBulk { // Exec executes the query. func (u *AccountUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the AccountCreateBulk instead", i) diff --git a/entc/integration/customid/ent/blob_create.go b/entc/integration/customid/ent/blob_create.go index 7b21b45bd..cfa876f9d 100644 --- a/entc/integration/customid/ent/blob_create.go +++ b/entc/integration/customid/ent/blob_create.go @@ -447,12 +447,16 @@ func (u *BlobUpsertOne) IDX(ctx context.Context) uuid.UUID { // BlobCreateBulk is the builder for creating many Blob entities in bulk. type BlobCreateBulk struct { config + err error builders []*BlobCreate conflict []sql.ConflictOption } // Save creates the Blob entities in the database. func (bcb *BlobCreateBulk) Save(ctx context.Context) ([]*Blob, error) { + if bcb.err != nil { + return nil, bcb.err + } specs := make([]*sqlgraph.CreateSpec, len(bcb.builders)) nodes := make([]*Blob, len(bcb.builders)) mutators := make([]Mutator, len(bcb.builders)) @@ -654,6 +658,9 @@ func (u *BlobUpsertBulk) UpdateCount() *BlobUpsertBulk { // Exec executes the query. func (u *BlobUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the BlobCreateBulk instead", i) diff --git a/entc/integration/customid/ent/bloblink_create.go b/entc/integration/customid/ent/bloblink_create.go index 855f675f0..b452e6b02 100644 --- a/entc/integration/customid/ent/bloblink_create.go +++ b/entc/integration/customid/ent/bloblink_create.go @@ -371,12 +371,16 @@ func (u *BlobLinkUpsertOne) ExecX(ctx context.Context) { // BlobLinkCreateBulk is the builder for creating many BlobLink entities in bulk. type BlobLinkCreateBulk struct { config + err error builders []*BlobLinkCreate conflict []sql.ConflictOption } // Save creates the BlobLink entities in the database. func (blcb *BlobLinkCreateBulk) Save(ctx context.Context) ([]*BlobLink, error) { + if blcb.err != nil { + return nil, blcb.err + } specs := make([]*sqlgraph.CreateSpec, len(blcb.builders)) nodes := make([]*BlobLink, len(blcb.builders)) mutators := make([]Mutator, len(blcb.builders)) @@ -574,6 +578,9 @@ func (u *BlobLinkUpsertBulk) UpdateLinkID() *BlobLinkUpsertBulk { // Exec executes the query. func (u *BlobLinkUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the BlobLinkCreateBulk instead", i) diff --git a/entc/integration/customid/ent/car_create.go b/entc/integration/customid/ent/car_create.go index 5bc79f2f7..86d45bfaf 100644 --- a/entc/integration/customid/ent/car_create.go +++ b/entc/integration/customid/ent/car_create.go @@ -465,12 +465,16 @@ func (u *CarUpsertOne) IDX(ctx context.Context) int { // CarCreateBulk is the builder for creating many Car entities in bulk. type CarCreateBulk struct { config + err error builders []*CarCreate conflict []sql.ConflictOption } // Save creates the Car entities in the database. func (ccb *CarCreateBulk) Save(ctx context.Context) ([]*Car, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Car, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) @@ -710,6 +714,9 @@ func (u *CarUpsertBulk) UpdateModel() *CarUpsertBulk { // Exec executes the query. func (u *CarUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the CarCreateBulk instead", i) diff --git a/entc/integration/customid/ent/client.go b/entc/integration/customid/ent/client.go index a3ce1a69f..7faeb5d5f 100644 --- a/entc/integration/customid/ent/client.go +++ b/entc/integration/customid/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/customid/ent/migrate" @@ -372,6 +373,21 @@ func (c *AccountClient) CreateBulk(builders ...*AccountCreate) *AccountCreateBul return &AccountCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *AccountClient) MapCreateBulk(slice any, setFunc func(*AccountCreate, int)) *AccountCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &AccountCreateBulk{err: fmt.Errorf("calling to AccountClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*AccountCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &AccountCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Account. func (c *AccountClient) Update() *AccountUpdate { mutation := newAccountMutation(c.config, OpUpdate) @@ -506,6 +522,21 @@ func (c *BlobClient) CreateBulk(builders ...*BlobCreate) *BlobCreateBulk { return &BlobCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *BlobClient) MapCreateBulk(slice any, setFunc func(*BlobCreate, int)) *BlobCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &BlobCreateBulk{err: fmt.Errorf("calling to BlobClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*BlobCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &BlobCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Blob. func (c *BlobClient) Update() *BlobUpdate { mutation := newBlobMutation(c.config, OpUpdate) @@ -672,6 +703,21 @@ func (c *BlobLinkClient) CreateBulk(builders ...*BlobLinkCreate) *BlobLinkCreate return &BlobLinkCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *BlobLinkClient) MapCreateBulk(slice any, setFunc func(*BlobLinkCreate, int)) *BlobLinkCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &BlobLinkCreateBulk{err: fmt.Errorf("calling to BlobLinkClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*BlobLinkCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &BlobLinkCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for BlobLink. func (c *BlobLinkClient) Update() *BlobLinkUpdate { mutation := newBlobLinkMutation(c.config, OpUpdate) @@ -773,6 +819,21 @@ func (c *CarClient) CreateBulk(builders ...*CarCreate) *CarCreateBulk { return &CarCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CarClient) MapCreateBulk(slice any, setFunc func(*CarCreate, int)) *CarCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CarCreateBulk{err: fmt.Errorf("calling to CarClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CarCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CarCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Car. func (c *CarClient) Update() *CarUpdate { mutation := newCarMutation(c.config, OpUpdate) @@ -907,6 +968,21 @@ func (c *DeviceClient) CreateBulk(builders ...*DeviceCreate) *DeviceCreateBulk { return &DeviceCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *DeviceClient) MapCreateBulk(slice any, setFunc func(*DeviceCreate, int)) *DeviceCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &DeviceCreateBulk{err: fmt.Errorf("calling to DeviceClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*DeviceCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &DeviceCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Device. func (c *DeviceClient) Update() *DeviceUpdate { mutation := newDeviceMutation(c.config, OpUpdate) @@ -1057,6 +1133,21 @@ func (c *DocClient) CreateBulk(builders ...*DocCreate) *DocCreateBulk { return &DocCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *DocClient) MapCreateBulk(slice any, setFunc func(*DocCreate, int)) *DocCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &DocCreateBulk{err: fmt.Errorf("calling to DocClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*DocCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &DocCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Doc. func (c *DocClient) Update() *DocUpdate { mutation := newDocMutation(c.config, OpUpdate) @@ -1223,6 +1314,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -1357,6 +1463,21 @@ func (c *IntSIDClient) CreateBulk(builders ...*IntSIDCreate) *IntSIDCreateBulk { return &IntSIDCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *IntSIDClient) MapCreateBulk(slice any, setFunc func(*IntSIDCreate, int)) *IntSIDCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &IntSIDCreateBulk{err: fmt.Errorf("calling to IntSIDClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*IntSIDCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &IntSIDCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for IntSID. func (c *IntSIDClient) Update() *IntSIDUpdate { mutation := newIntSIDMutation(c.config, OpUpdate) @@ -1507,6 +1628,21 @@ func (c *LinkClient) CreateBulk(builders ...*LinkCreate) *LinkCreateBulk { return &LinkCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *LinkClient) MapCreateBulk(slice any, setFunc func(*LinkCreate, int)) *LinkCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &LinkCreateBulk{err: fmt.Errorf("calling to LinkClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*LinkCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &LinkCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Link. func (c *LinkClient) Update() *LinkUpdate { mutation := newLinkMutation(c.config, OpUpdate) @@ -1625,6 +1761,21 @@ func (c *MixinIDClient) CreateBulk(builders ...*MixinIDCreate) *MixinIDCreateBul return &MixinIDCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *MixinIDClient) MapCreateBulk(slice any, setFunc func(*MixinIDCreate, int)) *MixinIDCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &MixinIDCreateBulk{err: fmt.Errorf("calling to MixinIDClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*MixinIDCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &MixinIDCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for MixinID. func (c *MixinIDClient) Update() *MixinIDUpdate { mutation := newMixinIDMutation(c.config, OpUpdate) @@ -1743,6 +1894,21 @@ func (c *NoteClient) CreateBulk(builders ...*NoteCreate) *NoteCreateBulk { return &NoteCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *NoteClient) MapCreateBulk(slice any, setFunc func(*NoteCreate, int)) *NoteCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &NoteCreateBulk{err: fmt.Errorf("calling to NoteClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*NoteCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &NoteCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Note. func (c *NoteClient) Update() *NoteUpdate { mutation := newNoteMutation(c.config, OpUpdate) @@ -1893,6 +2059,21 @@ func (c *OtherClient) CreateBulk(builders ...*OtherCreate) *OtherCreateBulk { return &OtherCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *OtherClient) MapCreateBulk(slice any, setFunc func(*OtherCreate, int)) *OtherCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &OtherCreateBulk{err: fmt.Errorf("calling to OtherClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*OtherCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &OtherCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Other. func (c *OtherClient) Update() *OtherUpdate { mutation := newOtherMutation(c.config, OpUpdate) @@ -2011,6 +2192,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -2193,6 +2389,21 @@ func (c *RevisionClient) CreateBulk(builders ...*RevisionCreate) *RevisionCreate return &RevisionCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *RevisionClient) MapCreateBulk(slice any, setFunc func(*RevisionCreate, int)) *RevisionCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &RevisionCreateBulk{err: fmt.Errorf("calling to RevisionClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*RevisionCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &RevisionCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Revision. func (c *RevisionClient) Update() *RevisionUpdate { mutation := newRevisionMutation(c.config, OpUpdate) @@ -2311,6 +2522,21 @@ func (c *SessionClient) CreateBulk(builders ...*SessionCreate) *SessionCreateBul return &SessionCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *SessionClient) MapCreateBulk(slice any, setFunc func(*SessionCreate, int)) *SessionCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &SessionCreateBulk{err: fmt.Errorf("calling to SessionClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*SessionCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &SessionCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Session. func (c *SessionClient) Update() *SessionUpdate { mutation := newSessionMutation(c.config, OpUpdate) @@ -2445,6 +2671,21 @@ func (c *TokenClient) CreateBulk(builders ...*TokenCreate) *TokenCreateBulk { return &TokenCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TokenClient) MapCreateBulk(slice any, setFunc func(*TokenCreate, int)) *TokenCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TokenCreateBulk{err: fmt.Errorf("calling to TokenClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TokenCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TokenCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Token. func (c *TokenClient) Update() *TokenUpdate { mutation := newTokenMutation(c.config, OpUpdate) @@ -2579,6 +2820,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/customid/ent/device_create.go b/entc/integration/customid/ent/device_create.go index 6ffd61d81..7e6d8ebb4 100644 --- a/entc/integration/customid/ent/device_create.go +++ b/entc/integration/customid/ent/device_create.go @@ -328,12 +328,16 @@ func (u *DeviceUpsertOne) IDX(ctx context.Context) schema.ID { // DeviceCreateBulk is the builder for creating many Device entities in bulk. type DeviceCreateBulk struct { config + err error builders []*DeviceCreate conflict []sql.ConflictOption } // Save creates the Device entities in the database. func (dcb *DeviceCreateBulk) Save(ctx context.Context) ([]*Device, error) { + if dcb.err != nil { + return nil, dcb.err + } specs := make([]*sqlgraph.CreateSpec, len(dcb.builders)) nodes := make([]*Device, len(dcb.builders)) mutators := make([]Mutator, len(dcb.builders)) @@ -495,6 +499,9 @@ func (u *DeviceUpsertBulk) Update(set func(*DeviceUpsert)) *DeviceUpsertBulk { // Exec executes the query. func (u *DeviceUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the DeviceCreateBulk instead", i) diff --git a/entc/integration/customid/ent/doc_create.go b/entc/integration/customid/ent/doc_create.go index a02037d4f..1719a90fb 100644 --- a/entc/integration/customid/ent/doc_create.go +++ b/entc/integration/customid/ent/doc_create.go @@ -421,12 +421,16 @@ func (u *DocUpsertOne) IDX(ctx context.Context) schema.DocID { // DocCreateBulk is the builder for creating many Doc entities in bulk. type DocCreateBulk struct { config + err error builders []*DocCreate conflict []sql.ConflictOption } // Save creates the Doc entities in the database. func (dcb *DocCreateBulk) Save(ctx context.Context) ([]*Doc, error) { + if dcb.err != nil { + return nil, dcb.err + } specs := make([]*sqlgraph.CreateSpec, len(dcb.builders)) nodes := make([]*Doc, len(dcb.builders)) mutators := make([]Mutator, len(dcb.builders)) @@ -614,6 +618,9 @@ func (u *DocUpsertBulk) ClearText() *DocUpsertBulk { // Exec executes the query. func (u *DocUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the DocCreateBulk instead", i) diff --git a/entc/integration/customid/ent/group_create.go b/entc/integration/customid/ent/group_create.go index 6b18b51a0..68cc9e374 100644 --- a/entc/integration/customid/ent/group_create.go +++ b/entc/integration/customid/ent/group_create.go @@ -260,12 +260,16 @@ func (u *GroupUpsertOne) IDX(ctx context.Context) int { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate conflict []sql.ConflictOption } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) @@ -430,6 +434,9 @@ func (u *GroupUpsertBulk) Update(set func(*GroupUpsert)) *GroupUpsertBulk { // Exec executes the query. func (u *GroupUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the GroupCreateBulk instead", i) diff --git a/entc/integration/customid/ent/intsid_create.go b/entc/integration/customid/ent/intsid_create.go index 7655f895e..8883b4cb5 100644 --- a/entc/integration/customid/ent/intsid_create.go +++ b/entc/integration/customid/ent/intsid_create.go @@ -299,12 +299,16 @@ func (u *IntSIDUpsertOne) IDX(ctx context.Context) sid.ID { // IntSIDCreateBulk is the builder for creating many IntSID entities in bulk. type IntSIDCreateBulk struct { config + err error builders []*IntSIDCreate conflict []sql.ConflictOption } // Save creates the IntSID entities in the database. func (iscb *IntSIDCreateBulk) Save(ctx context.Context) ([]*IntSID, error) { + if iscb.err != nil { + return nil, iscb.err + } specs := make([]*sqlgraph.CreateSpec, len(iscb.builders)) nodes := make([]*IntSID, len(iscb.builders)) mutators := make([]Mutator, len(iscb.builders)) @@ -470,6 +474,9 @@ func (u *IntSIDUpsertBulk) Update(set func(*IntSIDUpsert)) *IntSIDUpsertBulk { // Exec executes the query. func (u *IntSIDUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the IntSIDCreateBulk instead", i) diff --git a/entc/integration/customid/ent/link_create.go b/entc/integration/customid/ent/link_create.go index 621a681c6..dbc89dd83 100644 --- a/entc/integration/customid/ent/link_create.go +++ b/entc/integration/customid/ent/link_create.go @@ -305,12 +305,16 @@ func (u *LinkUpsertOne) IDX(ctx context.Context) uuidc.UUIDC { // LinkCreateBulk is the builder for creating many Link entities in bulk. type LinkCreateBulk struct { config + err error builders []*LinkCreate conflict []sql.ConflictOption } // Save creates the Link entities in the database. func (lcb *LinkCreateBulk) Save(ctx context.Context) ([]*Link, error) { + if lcb.err != nil { + return nil, lcb.err + } specs := make([]*sqlgraph.CreateSpec, len(lcb.builders)) nodes := make([]*Link, len(lcb.builders)) mutators := make([]Mutator, len(lcb.builders)) @@ -491,6 +495,9 @@ func (u *LinkUpsertBulk) UpdateLinkInformation() *LinkUpsertBulk { // Exec executes the query. func (u *LinkUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the LinkCreateBulk instead", i) diff --git a/entc/integration/customid/ent/mixinid_create.go b/entc/integration/customid/ent/mixinid_create.go index ad76395da..03b713edf 100644 --- a/entc/integration/customid/ent/mixinid_create.go +++ b/entc/integration/customid/ent/mixinid_create.go @@ -339,12 +339,16 @@ func (u *MixinIDUpsertOne) IDX(ctx context.Context) uuid.UUID { // MixinIDCreateBulk is the builder for creating many MixinID entities in bulk. type MixinIDCreateBulk struct { config + err error builders []*MixinIDCreate conflict []sql.ConflictOption } // Save creates the MixinID entities in the database. func (micb *MixinIDCreateBulk) Save(ctx context.Context) ([]*MixinID, error) { + if micb.err != nil { + return nil, micb.err + } specs := make([]*sqlgraph.CreateSpec, len(micb.builders)) nodes := make([]*MixinID, len(micb.builders)) mutators := make([]Mutator, len(micb.builders)) @@ -539,6 +543,9 @@ func (u *MixinIDUpsertBulk) UpdateMixinField() *MixinIDUpsertBulk { // Exec executes the query. func (u *MixinIDUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the MixinIDCreateBulk instead", i) diff --git a/entc/integration/customid/ent/note_create.go b/entc/integration/customid/ent/note_create.go index 5c9177591..a55a8d612 100644 --- a/entc/integration/customid/ent/note_create.go +++ b/entc/integration/customid/ent/note_create.go @@ -390,12 +390,16 @@ func (u *NoteUpsertOne) IDX(ctx context.Context) schema.NoteID { // NoteCreateBulk is the builder for creating many Note entities in bulk. type NoteCreateBulk struct { config + err error builders []*NoteCreate conflict []sql.ConflictOption } // Save creates the Note entities in the database. func (ncb *NoteCreateBulk) Save(ctx context.Context) ([]*Note, error) { + if ncb.err != nil { + return nil, ncb.err + } specs := make([]*sqlgraph.CreateSpec, len(ncb.builders)) nodes := make([]*Note, len(ncb.builders)) mutators := make([]Mutator, len(ncb.builders)) @@ -583,6 +587,9 @@ func (u *NoteUpsertBulk) ClearText() *NoteUpsertBulk { // Exec executes the query. func (u *NoteUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the NoteCreateBulk instead", i) diff --git a/entc/integration/customid/ent/other_create.go b/entc/integration/customid/ent/other_create.go index c109100cf..aeb0d70e9 100644 --- a/entc/integration/customid/ent/other_create.go +++ b/entc/integration/customid/ent/other_create.go @@ -255,12 +255,16 @@ func (u *OtherUpsertOne) IDX(ctx context.Context) sid.ID { // OtherCreateBulk is the builder for creating many Other entities in bulk. type OtherCreateBulk struct { config + err error builders []*OtherCreate conflict []sql.ConflictOption } // Save creates the Other entities in the database. func (ocb *OtherCreateBulk) Save(ctx context.Context) ([]*Other, error) { + if ocb.err != nil { + return nil, ocb.err + } specs := make([]*sqlgraph.CreateSpec, len(ocb.builders)) nodes := make([]*Other, len(ocb.builders)) mutators := make([]Mutator, len(ocb.builders)) @@ -422,6 +426,9 @@ func (u *OtherUpsertBulk) Update(set func(*OtherUpsert)) *OtherUpsertBulk { // Exec executes the query. func (u *OtherUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the OtherCreateBulk instead", i) diff --git a/entc/integration/customid/ent/pet_create.go b/entc/integration/customid/ent/pet_create.go index bb8e57b6f..5146e144b 100644 --- a/entc/integration/customid/ent/pet_create.go +++ b/entc/integration/customid/ent/pet_create.go @@ -395,12 +395,16 @@ func (u *PetUpsertOne) IDX(ctx context.Context) string { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate conflict []sql.ConflictOption } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) @@ -562,6 +566,9 @@ func (u *PetUpsertBulk) Update(set func(*PetUpsert)) *PetUpsertBulk { // Exec executes the query. func (u *PetUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the PetCreateBulk instead", i) diff --git a/entc/integration/customid/ent/revision_create.go b/entc/integration/customid/ent/revision_create.go index 68e0dfcf2..8bf73dde4 100644 --- a/entc/integration/customid/ent/revision_create.go +++ b/entc/integration/customid/ent/revision_create.go @@ -237,12 +237,16 @@ func (u *RevisionUpsertOne) IDX(ctx context.Context) string { // RevisionCreateBulk is the builder for creating many Revision entities in bulk. type RevisionCreateBulk struct { config + err error builders []*RevisionCreate conflict []sql.ConflictOption } // Save creates the Revision entities in the database. func (rcb *RevisionCreateBulk) Save(ctx context.Context) ([]*Revision, error) { + if rcb.err != nil { + return nil, rcb.err + } specs := make([]*sqlgraph.CreateSpec, len(rcb.builders)) nodes := make([]*Revision, len(rcb.builders)) mutators := make([]Mutator, len(rcb.builders)) @@ -403,6 +407,9 @@ func (u *RevisionUpsertBulk) Update(set func(*RevisionUpsert)) *RevisionUpsertBu // Exec executes the query. func (u *RevisionUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the RevisionCreateBulk instead", i) diff --git a/entc/integration/customid/ent/session_create.go b/entc/integration/customid/ent/session_create.go index 96a9bfdd9..0d892d844 100644 --- a/entc/integration/customid/ent/session_create.go +++ b/entc/integration/customid/ent/session_create.go @@ -297,12 +297,16 @@ func (u *SessionUpsertOne) IDX(ctx context.Context) schema.ID { // SessionCreateBulk is the builder for creating many Session entities in bulk. type SessionCreateBulk struct { config + err error builders []*SessionCreate conflict []sql.ConflictOption } // Save creates the Session entities in the database. func (scb *SessionCreateBulk) Save(ctx context.Context) ([]*Session, error) { + if scb.err != nil { + return nil, scb.err + } specs := make([]*sqlgraph.CreateSpec, len(scb.builders)) nodes := make([]*Session, len(scb.builders)) mutators := make([]Mutator, len(scb.builders)) @@ -464,6 +468,9 @@ func (u *SessionUpsertBulk) Update(set func(*SessionUpsert)) *SessionUpsertBulk // Exec executes the query. func (u *SessionUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the SessionCreateBulk instead", i) diff --git a/entc/integration/customid/ent/token_create.go b/entc/integration/customid/ent/token_create.go index 27f52f1ab..e05d9761e 100644 --- a/entc/integration/customid/ent/token_create.go +++ b/entc/integration/customid/ent/token_create.go @@ -337,12 +337,16 @@ func (u *TokenUpsertOne) IDX(ctx context.Context) sid.ID { // TokenCreateBulk is the builder for creating many Token entities in bulk. type TokenCreateBulk struct { config + err error builders []*TokenCreate conflict []sql.ConflictOption } // Save creates the Token entities in the database. func (tcb *TokenCreateBulk) Save(ctx context.Context) ([]*Token, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Token, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) @@ -523,6 +527,9 @@ func (u *TokenUpsertBulk) UpdateBody() *TokenUpsertBulk { // Exec executes the query. func (u *TokenUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the TokenCreateBulk instead", i) diff --git a/entc/integration/customid/ent/user_create.go b/entc/integration/customid/ent/user_create.go index bcfbeb552..edf7c8f19 100644 --- a/entc/integration/customid/ent/user_create.go +++ b/entc/integration/customid/ent/user_create.go @@ -359,12 +359,16 @@ func (u *UserUpsertOne) IDX(ctx context.Context) int { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate conflict []sql.ConflictOption } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) @@ -529,6 +533,9 @@ func (u *UserUpsertBulk) Update(set func(*UserUpsert)) *UserUpsertBulk { // Exec executes the query. func (u *UserUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the UserCreateBulk instead", i) diff --git a/entc/integration/edgefield/ent/car_create.go b/entc/integration/edgefield/ent/car_create.go index 643d6f1cb..38fd2d984 100644 --- a/entc/integration/edgefield/ent/car_create.go +++ b/entc/integration/edgefield/ent/car_create.go @@ -171,11 +171,15 @@ func (cc *CarCreate) createSpec() (*Car, *sqlgraph.CreateSpec) { // CarCreateBulk is the builder for creating many Car entities in bulk. type CarCreateBulk struct { config + err error builders []*CarCreate } // Save creates the Car entities in the database. func (ccb *CarCreateBulk) Save(ctx context.Context) ([]*Car, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Car, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/edgefield/ent/card_create.go b/entc/integration/edgefield/ent/card_create.go index 1e4896993..16f4be92c 100644 --- a/entc/integration/edgefield/ent/card_create.go +++ b/entc/integration/edgefield/ent/card_create.go @@ -143,11 +143,15 @@ func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate } // Save creates the Card entities in the database. func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Card, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/edgefield/ent/client.go b/entc/integration/edgefield/ent/client.go index 3dfcf6f1a..a08fd17bf 100644 --- a/entc/integration/edgefield/ent/client.go +++ b/entc/integration/edgefield/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/edgefield/ent/migrate" @@ -301,6 +302,21 @@ func (c *CarClient) CreateBulk(builders ...*CarCreate) *CarCreateBulk { return &CarCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CarClient) MapCreateBulk(slice any, setFunc func(*CarCreate, int)) *CarCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CarCreateBulk{err: fmt.Errorf("calling to CarClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CarCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CarCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Car. func (c *CarClient) Update() *CarUpdate { mutation := newCarMutation(c.config, OpUpdate) @@ -435,6 +451,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -569,6 +600,21 @@ func (c *InfoClient) CreateBulk(builders ...*InfoCreate) *InfoCreateBulk { return &InfoCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *InfoClient) MapCreateBulk(slice any, setFunc func(*InfoCreate, int)) *InfoCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &InfoCreateBulk{err: fmt.Errorf("calling to InfoClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*InfoCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &InfoCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Info. func (c *InfoClient) Update() *InfoUpdate { mutation := newInfoMutation(c.config, OpUpdate) @@ -703,6 +749,21 @@ func (c *MetadataClient) CreateBulk(builders ...*MetadataCreate) *MetadataCreate return &MetadataCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *MetadataClient) MapCreateBulk(slice any, setFunc func(*MetadataCreate, int)) *MetadataCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &MetadataCreateBulk{err: fmt.Errorf("calling to MetadataClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*MetadataCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &MetadataCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Metadata. func (c *MetadataClient) Update() *MetadataUpdate { mutation := newMetadataMutation(c.config, OpUpdate) @@ -869,6 +930,21 @@ func (c *NodeClient) CreateBulk(builders ...*NodeCreate) *NodeCreateBulk { return &NodeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *NodeClient) MapCreateBulk(slice any, setFunc func(*NodeCreate, int)) *NodeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &NodeCreateBulk{err: fmt.Errorf("calling to NodeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*NodeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &NodeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Node. func (c *NodeClient) Update() *NodeUpdate { mutation := newNodeMutation(c.config, OpUpdate) @@ -1019,6 +1095,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -1153,6 +1244,21 @@ func (c *PostClient) CreateBulk(builders ...*PostCreate) *PostCreateBulk { return &PostCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PostClient) MapCreateBulk(slice any, setFunc func(*PostCreate, int)) *PostCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PostCreateBulk{err: fmt.Errorf("calling to PostClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PostCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PostCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Post. func (c *PostClient) Update() *PostUpdate { mutation := newPostMutation(c.config, OpUpdate) @@ -1287,6 +1393,21 @@ func (c *RentalClient) CreateBulk(builders ...*RentalCreate) *RentalCreateBulk { return &RentalCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *RentalClient) MapCreateBulk(slice any, setFunc func(*RentalCreate, int)) *RentalCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &RentalCreateBulk{err: fmt.Errorf("calling to RentalClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*RentalCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &RentalCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Rental. func (c *RentalClient) Update() *RentalUpdate { mutation := newRentalMutation(c.config, OpUpdate) @@ -1437,6 +1558,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/edgefield/ent/info_create.go b/entc/integration/edgefield/ent/info_create.go index 70a8e3312..dde370f77 100644 --- a/entc/integration/edgefield/ent/info_create.go +++ b/entc/integration/edgefield/ent/info_create.go @@ -152,11 +152,15 @@ func (ic *InfoCreate) createSpec() (*Info, *sqlgraph.CreateSpec) { // InfoCreateBulk is the builder for creating many Info entities in bulk. type InfoCreateBulk struct { config + err error builders []*InfoCreate } // Save creates the Info entities in the database. func (icb *InfoCreateBulk) Save(ctx context.Context) ([]*Info, error) { + if icb.err != nil { + return nil, icb.err + } specs := make([]*sqlgraph.CreateSpec, len(icb.builders)) nodes := make([]*Info, len(icb.builders)) mutators := make([]Mutator, len(icb.builders)) diff --git a/entc/integration/edgefield/ent/metadata_create.go b/entc/integration/edgefield/ent/metadata_create.go index 1665afa5f..5ca219289 100644 --- a/entc/integration/edgefield/ent/metadata_create.go +++ b/entc/integration/edgefield/ent/metadata_create.go @@ -235,11 +235,15 @@ func (mc *MetadataCreate) createSpec() (*Metadata, *sqlgraph.CreateSpec) { // MetadataCreateBulk is the builder for creating many Metadata entities in bulk. type MetadataCreateBulk struct { config + err error builders []*MetadataCreate } // Save creates the Metadata entities in the database. func (mcb *MetadataCreateBulk) Save(ctx context.Context) ([]*Metadata, error) { + if mcb.err != nil { + return nil, mcb.err + } specs := make([]*sqlgraph.CreateSpec, len(mcb.builders)) nodes := make([]*Metadata, len(mcb.builders)) mutators := make([]Mutator, len(mcb.builders)) diff --git a/entc/integration/edgefield/ent/node_create.go b/entc/integration/edgefield/ent/node_create.go index 30c859ec8..4111565c4 100644 --- a/entc/integration/edgefield/ent/node_create.go +++ b/entc/integration/edgefield/ent/node_create.go @@ -190,11 +190,15 @@ func (nc *NodeCreate) createSpec() (*Node, *sqlgraph.CreateSpec) { // NodeCreateBulk is the builder for creating many Node entities in bulk. type NodeCreateBulk struct { config + err error builders []*NodeCreate } // Save creates the Node entities in the database. func (ncb *NodeCreateBulk) Save(ctx context.Context) ([]*Node, error) { + if ncb.err != nil { + return nil, ncb.err + } specs := make([]*sqlgraph.CreateSpec, len(ncb.builders)) nodes := make([]*Node, len(ncb.builders)) mutators := make([]Mutator, len(ncb.builders)) diff --git a/entc/integration/edgefield/ent/pet_create.go b/entc/integration/edgefield/ent/pet_create.go index 6d4969df9..6af384398 100644 --- a/entc/integration/edgefield/ent/pet_create.go +++ b/entc/integration/edgefield/ent/pet_create.go @@ -125,11 +125,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/edgefield/ent/post_create.go b/entc/integration/edgefield/ent/post_create.go index 51b9be102..8854bb890 100644 --- a/entc/integration/edgefield/ent/post_create.go +++ b/entc/integration/edgefield/ent/post_create.go @@ -139,11 +139,15 @@ func (pc *PostCreate) createSpec() (*Post, *sqlgraph.CreateSpec) { // PostCreateBulk is the builder for creating many Post entities in bulk. type PostCreateBulk struct { config + err error builders []*PostCreate } // Save creates the Post entities in the database. func (pcb *PostCreateBulk) Save(ctx context.Context) ([]*Post, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Post, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/edgefield/ent/rental_create.go b/entc/integration/edgefield/ent/rental_create.go index 54be32322..913dc8f88 100644 --- a/entc/integration/edgefield/ent/rental_create.go +++ b/entc/integration/edgefield/ent/rental_create.go @@ -191,11 +191,15 @@ func (rc *RentalCreate) createSpec() (*Rental, *sqlgraph.CreateSpec) { // RentalCreateBulk is the builder for creating many Rental entities in bulk. type RentalCreateBulk struct { config + err error builders []*RentalCreate } // Save creates the Rental entities in the database. func (rcb *RentalCreateBulk) Save(ctx context.Context) ([]*Rental, error) { + if rcb.err != nil { + return nil, rcb.err + } specs := make([]*sqlgraph.CreateSpec, len(rcb.builders)) nodes := make([]*Rental, len(rcb.builders)) mutators := make([]Mutator, len(rcb.builders)) diff --git a/entc/integration/edgefield/ent/user_create.go b/entc/integration/edgefield/ent/user_create.go index fc24afa99..958e74e81 100644 --- a/entc/integration/edgefield/ent/user_create.go +++ b/entc/integration/edgefield/ent/user_create.go @@ -371,11 +371,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/edgeschema/ent/attachedfile_create.go b/entc/integration/edgeschema/ent/attachedfile_create.go index d91b8719e..83e4f8d20 100644 --- a/entc/integration/edgeschema/ent/attachedfile_create.go +++ b/entc/integration/edgeschema/ent/attachedfile_create.go @@ -399,12 +399,16 @@ func (u *AttachedFileUpsertOne) IDX(ctx context.Context) int { // AttachedFileCreateBulk is the builder for creating many AttachedFile entities in bulk. type AttachedFileCreateBulk struct { config + err error builders []*AttachedFileCreate conflict []sql.ConflictOption } // Save creates the AttachedFile entities in the database. func (afcb *AttachedFileCreateBulk) Save(ctx context.Context) ([]*AttachedFile, error) { + if afcb.err != nil { + return nil, afcb.err + } specs := make([]*sqlgraph.CreateSpec, len(afcb.builders)) nodes := make([]*AttachedFile, len(afcb.builders)) mutators := make([]Mutator, len(afcb.builders)) @@ -607,6 +611,9 @@ func (u *AttachedFileUpsertBulk) UpdateProcID() *AttachedFileUpsertBulk { // Exec executes the query. func (u *AttachedFileUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the AttachedFileCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/client.go b/entc/integration/edgeschema/ent/client.go index e3db03720..d5e637bbb 100644 --- a/entc/integration/edgeschema/ent/client.go +++ b/entc/integration/edgeschema/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/edgeschema/ent/migrate" @@ -369,6 +370,21 @@ func (c *AttachedFileClient) CreateBulk(builders ...*AttachedFileCreate) *Attach return &AttachedFileCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *AttachedFileClient) MapCreateBulk(slice any, setFunc func(*AttachedFileCreate, int)) *AttachedFileCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &AttachedFileCreateBulk{err: fmt.Errorf("calling to AttachedFileClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*AttachedFileCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &AttachedFileCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for AttachedFile. func (c *AttachedFileClient) Update() *AttachedFileUpdate { mutation := newAttachedFileMutation(c.config, OpUpdate) @@ -519,6 +535,21 @@ func (c *FileClient) CreateBulk(builders ...*FileCreate) *FileCreateBulk { return &FileCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FileClient) MapCreateBulk(slice any, setFunc func(*FileCreate, int)) *FileCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FileCreateBulk{err: fmt.Errorf("calling to FileClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FileCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FileCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for File. func (c *FileClient) Update() *FileUpdate { mutation := newFileMutation(c.config, OpUpdate) @@ -653,6 +684,21 @@ func (c *FriendshipClient) CreateBulk(builders ...*FriendshipCreate) *Friendship return &FriendshipCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FriendshipClient) MapCreateBulk(slice any, setFunc func(*FriendshipCreate, int)) *FriendshipCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FriendshipCreateBulk{err: fmt.Errorf("calling to FriendshipClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FriendshipCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FriendshipCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Friendship. func (c *FriendshipClient) Update() *FriendshipUpdate { mutation := newFriendshipMutation(c.config, OpUpdate) @@ -803,6 +849,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -985,6 +1046,21 @@ func (c *GroupTagClient) CreateBulk(builders ...*GroupTagCreate) *GroupTagCreate return &GroupTagCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupTagClient) MapCreateBulk(slice any, setFunc func(*GroupTagCreate, int)) *GroupTagCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupTagCreateBulk{err: fmt.Errorf("calling to GroupTagClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupTagCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupTagCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for GroupTag. func (c *GroupTagClient) Update() *GroupTagUpdate { mutation := newGroupTagMutation(c.config, OpUpdate) @@ -1135,6 +1211,21 @@ func (c *ProcessClient) CreateBulk(builders ...*ProcessCreate) *ProcessCreateBul return &ProcessCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ProcessClient) MapCreateBulk(slice any, setFunc func(*ProcessCreate, int)) *ProcessCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ProcessCreateBulk{err: fmt.Errorf("calling to ProcessClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ProcessCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ProcessCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Process. func (c *ProcessClient) Update() *ProcessUpdate { mutation := newProcessMutation(c.config, OpUpdate) @@ -1285,6 +1376,21 @@ func (c *RelationshipClient) CreateBulk(builders ...*RelationshipCreate) *Relati return &RelationshipCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *RelationshipClient) MapCreateBulk(slice any, setFunc func(*RelationshipCreate, int)) *RelationshipCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &RelationshipCreateBulk{err: fmt.Errorf("calling to RelationshipClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*RelationshipCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &RelationshipCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Relationship. func (c *RelationshipClient) Update() *RelationshipUpdate { mutation := newRelationshipMutation(c.config, OpUpdate) @@ -1394,6 +1500,21 @@ func (c *RelationshipInfoClient) CreateBulk(builders ...*RelationshipInfoCreate) return &RelationshipInfoCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *RelationshipInfoClient) MapCreateBulk(slice any, setFunc func(*RelationshipInfoCreate, int)) *RelationshipInfoCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &RelationshipInfoCreateBulk{err: fmt.Errorf("calling to RelationshipInfoClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*RelationshipInfoCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &RelationshipInfoCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for RelationshipInfo. func (c *RelationshipInfoClient) Update() *RelationshipInfoUpdate { mutation := newRelationshipInfoMutation(c.config, OpUpdate) @@ -1512,6 +1633,21 @@ func (c *RoleClient) CreateBulk(builders ...*RoleCreate) *RoleCreateBulk { return &RoleCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *RoleClient) MapCreateBulk(slice any, setFunc func(*RoleCreate, int)) *RoleCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &RoleCreateBulk{err: fmt.Errorf("calling to RoleClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*RoleCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &RoleCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Role. func (c *RoleClient) Update() *RoleUpdate { mutation := newRoleMutation(c.config, OpUpdate) @@ -1662,6 +1798,21 @@ func (c *RoleUserClient) CreateBulk(builders ...*RoleUserCreate) *RoleUserCreate return &RoleUserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *RoleUserClient) MapCreateBulk(slice any, setFunc func(*RoleUserCreate, int)) *RoleUserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &RoleUserCreateBulk{err: fmt.Errorf("calling to RoleUserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*RoleUserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &RoleUserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for RoleUser. func (c *RoleUserClient) Update() *RoleUserUpdate { mutation := newRoleUserMutation(c.config, OpUpdate) @@ -1763,6 +1914,21 @@ func (c *TagClient) CreateBulk(builders ...*TagCreate) *TagCreateBulk { return &TagCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TagClient) MapCreateBulk(slice any, setFunc func(*TagCreate, int)) *TagCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TagCreateBulk{err: fmt.Errorf("calling to TagClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TagCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TagCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Tag. func (c *TagClient) Update() *TagUpdate { mutation := newTagMutation(c.config, OpUpdate) @@ -1945,6 +2111,21 @@ func (c *TweetClient) CreateBulk(builders ...*TweetCreate) *TweetCreateBulk { return &TweetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TweetClient) MapCreateBulk(slice any, setFunc func(*TweetCreate, int)) *TweetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TweetCreateBulk{err: fmt.Errorf("calling to TweetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TweetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TweetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Tweet. func (c *TweetClient) Update() *TweetUpdate { mutation := newTweetMutation(c.config, OpUpdate) @@ -2159,6 +2340,21 @@ func (c *TweetLikeClient) CreateBulk(builders ...*TweetLikeCreate) *TweetLikeCre return &TweetLikeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TweetLikeClient) MapCreateBulk(slice any, setFunc func(*TweetLikeCreate, int)) *TweetLikeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TweetLikeCreateBulk{err: fmt.Errorf("calling to TweetLikeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TweetLikeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TweetLikeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for TweetLike. func (c *TweetLikeClient) Update() *TweetLikeUpdate { mutation := newTweetLikeMutation(c.config, OpUpdate) @@ -2261,6 +2457,21 @@ func (c *TweetTagClient) CreateBulk(builders ...*TweetTagCreate) *TweetTagCreate return &TweetTagCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TweetTagClient) MapCreateBulk(slice any, setFunc func(*TweetTagCreate, int)) *TweetTagCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TweetTagCreateBulk{err: fmt.Errorf("calling to TweetTagClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TweetTagCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TweetTagCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for TweetTag. func (c *TweetTagClient) Update() *TweetTagUpdate { mutation := newTweetTagMutation(c.config, OpUpdate) @@ -2411,6 +2622,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) @@ -2722,6 +2948,21 @@ func (c *UserGroupClient) CreateBulk(builders ...*UserGroupCreate) *UserGroupCre return &UserGroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserGroupClient) MapCreateBulk(slice any, setFunc func(*UserGroupCreate, int)) *UserGroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserGroupCreateBulk{err: fmt.Errorf("calling to UserGroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserGroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserGroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for UserGroup. func (c *UserGroupClient) Update() *UserGroupUpdate { mutation := newUserGroupMutation(c.config, OpUpdate) @@ -2872,6 +3113,21 @@ func (c *UserTweetClient) CreateBulk(builders ...*UserTweetCreate) *UserTweetCre return &UserTweetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserTweetClient) MapCreateBulk(slice any, setFunc func(*UserTweetCreate, int)) *UserTweetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserTweetCreateBulk{err: fmt.Errorf("calling to UserTweetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserTweetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserTweetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for UserTweet. func (c *UserTweetClient) Update() *UserTweetUpdate { mutation := newUserTweetMutation(c.config, OpUpdate) diff --git a/entc/integration/edgeschema/ent/file_create.go b/entc/integration/edgeschema/ent/file_create.go index f81dcdffd..e68f2dc51 100644 --- a/entc/integration/edgeschema/ent/file_create.go +++ b/entc/integration/edgeschema/ent/file_create.go @@ -285,12 +285,16 @@ func (u *FileUpsertOne) IDX(ctx context.Context) int { // FileCreateBulk is the builder for creating many File entities in bulk. type FileCreateBulk struct { config + err error builders []*FileCreate conflict []sql.ConflictOption } // Save creates the File entities in the database. func (fcb *FileCreateBulk) Save(ctx context.Context) ([]*File, error) { + if fcb.err != nil { + return nil, fcb.err + } specs := make([]*sqlgraph.CreateSpec, len(fcb.builders)) nodes := make([]*File, len(fcb.builders)) mutators := make([]Mutator, len(fcb.builders)) @@ -464,6 +468,9 @@ func (u *FileUpsertBulk) UpdateName() *FileUpsertBulk { // Exec executes the query. func (u *FileUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the FileCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/friendship_create.go b/entc/integration/edgeschema/ent/friendship_create.go index b24e9872e..64ae41277 100644 --- a/entc/integration/edgeschema/ent/friendship_create.go +++ b/entc/integration/edgeschema/ent/friendship_create.go @@ -412,12 +412,16 @@ func (u *FriendshipUpsertOne) IDX(ctx context.Context) int { // FriendshipCreateBulk is the builder for creating many Friendship entities in bulk. type FriendshipCreateBulk struct { config + err error builders []*FriendshipCreate conflict []sql.ConflictOption } // Save creates the Friendship entities in the database. func (fcb *FriendshipCreateBulk) Save(ctx context.Context) ([]*Friendship, error) { + if fcb.err != nil { + return nil, fcb.err + } specs := make([]*sqlgraph.CreateSpec, len(fcb.builders)) nodes := make([]*Friendship, len(fcb.builders)) mutators := make([]Mutator, len(fcb.builders)) @@ -623,6 +627,9 @@ func (u *FriendshipUpsertBulk) UpdateCreatedAt() *FriendshipUpsertBulk { // Exec executes the query. func (u *FriendshipUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the FriendshipCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/group_create.go b/entc/integration/edgeschema/ent/group_create.go index 5dee031bb..ce202b6e2 100644 --- a/entc/integration/edgeschema/ent/group_create.go +++ b/entc/integration/edgeschema/ent/group_create.go @@ -402,12 +402,16 @@ func (u *GroupUpsertOne) IDX(ctx context.Context) int { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate conflict []sql.ConflictOption } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) @@ -582,6 +586,9 @@ func (u *GroupUpsertBulk) UpdateName() *GroupUpsertBulk { // Exec executes the query. func (u *GroupUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the GroupCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/grouptag_create.go b/entc/integration/edgeschema/ent/grouptag_create.go index 34cdf8c66..9b03eca00 100644 --- a/entc/integration/edgeschema/ent/grouptag_create.go +++ b/entc/integration/edgeschema/ent/grouptag_create.go @@ -336,12 +336,16 @@ func (u *GroupTagUpsertOne) IDX(ctx context.Context) int { // GroupTagCreateBulk is the builder for creating many GroupTag entities in bulk. type GroupTagCreateBulk struct { config + err error builders []*GroupTagCreate conflict []sql.ConflictOption } // Save creates the GroupTag entities in the database. func (gtcb *GroupTagCreateBulk) Save(ctx context.Context) ([]*GroupTag, error) { + if gtcb.err != nil { + return nil, gtcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gtcb.builders)) nodes := make([]*GroupTag, len(gtcb.builders)) mutators := make([]Mutator, len(gtcb.builders)) @@ -529,6 +533,9 @@ func (u *GroupTagUpsertBulk) UpdateGroupID() *GroupTagUpsertBulk { // Exec executes the query. func (u *GroupTagUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the GroupTagCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/process_create.go b/entc/integration/edgeschema/ent/process_create.go index 7a9dd5b07..f768ee183 100644 --- a/entc/integration/edgeschema/ent/process_create.go +++ b/entc/integration/edgeschema/ent/process_create.go @@ -276,12 +276,16 @@ func (u *ProcessUpsertOne) IDX(ctx context.Context) int { // ProcessCreateBulk is the builder for creating many Process entities in bulk. type ProcessCreateBulk struct { config + err error builders []*ProcessCreate conflict []sql.ConflictOption } // Save creates the Process entities in the database. func (pcb *ProcessCreateBulk) Save(ctx context.Context) ([]*Process, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Process, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) @@ -436,6 +440,9 @@ func (u *ProcessUpsertBulk) Update(set func(*ProcessUpsert)) *ProcessUpsertBulk // Exec executes the query. func (u *ProcessUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the ProcessCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/relationship_create.go b/entc/integration/edgeschema/ent/relationship_create.go index 39c4f762f..133c9a025 100644 --- a/entc/integration/edgeschema/ent/relationship_create.go +++ b/entc/integration/edgeschema/ent/relationship_create.go @@ -461,12 +461,16 @@ func (u *RelationshipUpsertOne) ExecX(ctx context.Context) { // RelationshipCreateBulk is the builder for creating many Relationship entities in bulk. type RelationshipCreateBulk struct { config + err error builders []*RelationshipCreate conflict []sql.ConflictOption } // Save creates the Relationship entities in the database. func (rcb *RelationshipCreateBulk) Save(ctx context.Context) ([]*Relationship, error) { + if rcb.err != nil { + return nil, rcb.err + } specs := make([]*sqlgraph.CreateSpec, len(rcb.builders)) nodes := make([]*Relationship, len(rcb.builders)) mutators := make([]Mutator, len(rcb.builders)) @@ -692,6 +696,9 @@ func (u *RelationshipUpsertBulk) ClearInfoID() *RelationshipUpsertBulk { // Exec executes the query. func (u *RelationshipUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the RelationshipCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/relationshipinfo_create.go b/entc/integration/edgeschema/ent/relationshipinfo_create.go index dbd4681f3..cb5d19886 100644 --- a/entc/integration/edgeschema/ent/relationshipinfo_create.go +++ b/entc/integration/edgeschema/ent/relationshipinfo_create.go @@ -253,12 +253,16 @@ func (u *RelationshipInfoUpsertOne) IDX(ctx context.Context) int { // RelationshipInfoCreateBulk is the builder for creating many RelationshipInfo entities in bulk. type RelationshipInfoCreateBulk struct { config + err error builders []*RelationshipInfoCreate conflict []sql.ConflictOption } // Save creates the RelationshipInfo entities in the database. func (ricb *RelationshipInfoCreateBulk) Save(ctx context.Context) ([]*RelationshipInfo, error) { + if ricb.err != nil { + return nil, ricb.err + } specs := make([]*sqlgraph.CreateSpec, len(ricb.builders)) nodes := make([]*RelationshipInfo, len(ricb.builders)) mutators := make([]Mutator, len(ricb.builders)) @@ -432,6 +436,9 @@ func (u *RelationshipInfoUpsertBulk) UpdateText() *RelationshipInfoUpsertBulk { // Exec executes the query. func (u *RelationshipInfoUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the RelationshipInfoCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/role_create.go b/entc/integration/edgeschema/ent/role_create.go index 4edcc4115..675791b31 100644 --- a/entc/integration/edgeschema/ent/role_create.go +++ b/entc/integration/edgeschema/ent/role_create.go @@ -346,12 +346,16 @@ func (u *RoleUpsertOne) IDX(ctx context.Context) int { // RoleCreateBulk is the builder for creating many Role entities in bulk. type RoleCreateBulk struct { config + err error builders []*RoleCreate conflict []sql.ConflictOption } // Save creates the Role entities in the database. func (rcb *RoleCreateBulk) Save(ctx context.Context) ([]*Role, error) { + if rcb.err != nil { + return nil, rcb.err + } specs := make([]*sqlgraph.CreateSpec, len(rcb.builders)) nodes := make([]*Role, len(rcb.builders)) mutators := make([]Mutator, len(rcb.builders)) @@ -540,6 +544,9 @@ func (u *RoleUpsertBulk) UpdateCreatedAt() *RoleUpsertBulk { // Exec executes the query. func (u *RoleUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the RoleCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/roleuser_create.go b/entc/integration/edgeschema/ent/roleuser_create.go index 5451835d6..3ac329608 100644 --- a/entc/integration/edgeschema/ent/roleuser_create.go +++ b/entc/integration/edgeschema/ent/roleuser_create.go @@ -371,12 +371,16 @@ func (u *RoleUserUpsertOne) ExecX(ctx context.Context) { // RoleUserCreateBulk is the builder for creating many RoleUser entities in bulk. type RoleUserCreateBulk struct { config + err error builders []*RoleUserCreate conflict []sql.ConflictOption } // Save creates the RoleUser entities in the database. func (rucb *RoleUserCreateBulk) Save(ctx context.Context) ([]*RoleUser, error) { + if rucb.err != nil { + return nil, rucb.err + } specs := make([]*sqlgraph.CreateSpec, len(rucb.builders)) nodes := make([]*RoleUser, len(rucb.builders)) mutators := make([]Mutator, len(rucb.builders)) @@ -574,6 +578,9 @@ func (u *RoleUserUpsertBulk) UpdateUserID() *RoleUserUpsertBulk { // Exec executes the query. func (u *RoleUserUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the RoleUserCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/tag_create.go b/entc/integration/edgeschema/ent/tag_create.go index 9decc9906..6fa36086b 100644 --- a/entc/integration/edgeschema/ent/tag_create.go +++ b/entc/integration/edgeschema/ent/tag_create.go @@ -389,12 +389,16 @@ func (u *TagUpsertOne) IDX(ctx context.Context) int { // TagCreateBulk is the builder for creating many Tag entities in bulk. type TagCreateBulk struct { config + err error builders []*TagCreate conflict []sql.ConflictOption } // Save creates the Tag entities in the database. func (tcb *TagCreateBulk) Save(ctx context.Context) ([]*Tag, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Tag, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) @@ -568,6 +572,9 @@ func (u *TagUpsertBulk) UpdateValue() *TagUpsertBulk { // Exec executes the query. func (u *TagUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the TagCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/tweet_create.go b/entc/integration/edgeschema/ent/tweet_create.go index 1ea8e3326..8a7b5a3f9 100644 --- a/entc/integration/edgeschema/ent/tweet_create.go +++ b/entc/integration/edgeschema/ent/tweet_create.go @@ -428,12 +428,16 @@ func (u *TweetUpsertOne) IDX(ctx context.Context) int { // TweetCreateBulk is the builder for creating many Tweet entities in bulk. type TweetCreateBulk struct { config + err error builders []*TweetCreate conflict []sql.ConflictOption } // Save creates the Tweet entities in the database. func (tcb *TweetCreateBulk) Save(ctx context.Context) ([]*Tweet, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Tweet, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) @@ -607,6 +611,9 @@ func (u *TweetUpsertBulk) UpdateText() *TweetUpsertBulk { // Exec executes the query. func (u *TweetUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the TweetCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/tweetlike_create.go b/entc/integration/edgeschema/ent/tweetlike_create.go index 92e1e3750..600e928e1 100644 --- a/entc/integration/edgeschema/ent/tweetlike_create.go +++ b/entc/integration/edgeschema/ent/tweetlike_create.go @@ -377,12 +377,16 @@ func (u *TweetLikeUpsertOne) ExecX(ctx context.Context) { // TweetLikeCreateBulk is the builder for creating many TweetLike entities in bulk. type TweetLikeCreateBulk struct { config + err error builders []*TweetLikeCreate conflict []sql.ConflictOption } // Save creates the TweetLike entities in the database. func (tlcb *TweetLikeCreateBulk) Save(ctx context.Context) ([]*TweetLike, error) { + if tlcb.err != nil { + return nil, tlcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tlcb.builders)) nodes := make([]*TweetLike, len(tlcb.builders)) mutators := make([]Mutator, len(tlcb.builders)) @@ -580,6 +584,9 @@ func (u *TweetLikeUpsertBulk) UpdateTweetID() *TweetLikeUpsertBulk { // Exec executes the query. func (u *TweetLikeUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the TweetLikeCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/tweettag_create.go b/entc/integration/edgeschema/ent/tweettag_create.go index 1ab4dd03a..aaaddae37 100644 --- a/entc/integration/edgeschema/ent/tweettag_create.go +++ b/entc/integration/edgeschema/ent/tweettag_create.go @@ -435,12 +435,16 @@ func (u *TweetTagUpsertOne) IDX(ctx context.Context) uuid.UUID { // TweetTagCreateBulk is the builder for creating many TweetTag entities in bulk. type TweetTagCreateBulk struct { config + err error builders []*TweetTagCreate conflict []sql.ConflictOption } // Save creates the TweetTag entities in the database. func (ttcb *TweetTagCreateBulk) Save(ctx context.Context) ([]*TweetTag, error) { + if ttcb.err != nil { + return nil, ttcb.err + } specs := make([]*sqlgraph.CreateSpec, len(ttcb.builders)) nodes := make([]*TweetTag, len(ttcb.builders)) mutators := make([]Mutator, len(ttcb.builders)) @@ -649,6 +653,9 @@ func (u *TweetTagUpsertBulk) UpdateTweetID() *TweetTagUpsertBulk { // Exec executes the query. func (u *TweetTagUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the TweetTagCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/user_create.go b/entc/integration/edgeschema/ent/user_create.go index 67ac74b2d..816439e9b 100644 --- a/entc/integration/edgeschema/ent/user_create.go +++ b/entc/integration/edgeschema/ent/user_create.go @@ -582,12 +582,16 @@ func (u *UserUpsertOne) IDX(ctx context.Context) int { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate conflict []sql.ConflictOption } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) @@ -762,6 +766,9 @@ func (u *UserUpsertBulk) UpdateName() *UserUpsertBulk { // Exec executes the query. func (u *UserUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the UserCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/usergroup_create.go b/entc/integration/edgeschema/ent/usergroup_create.go index 23d59c25d..a3bab9138 100644 --- a/entc/integration/edgeschema/ent/usergroup_create.go +++ b/entc/integration/edgeschema/ent/usergroup_create.go @@ -393,12 +393,16 @@ func (u *UserGroupUpsertOne) IDX(ctx context.Context) int { // UserGroupCreateBulk is the builder for creating many UserGroup entities in bulk. type UserGroupCreateBulk struct { config + err error builders []*UserGroupCreate conflict []sql.ConflictOption } // Save creates the UserGroup entities in the database. func (ugcb *UserGroupCreateBulk) Save(ctx context.Context) ([]*UserGroup, error) { + if ugcb.err != nil { + return nil, ugcb.err + } specs := make([]*sqlgraph.CreateSpec, len(ugcb.builders)) nodes := make([]*UserGroup, len(ugcb.builders)) mutators := make([]Mutator, len(ugcb.builders)) @@ -601,6 +605,9 @@ func (u *UserGroupUpsertBulk) UpdateGroupID() *UserGroupUpsertBulk { // Exec executes the query. func (u *UserGroupUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the UserGroupCreateBulk instead", i) diff --git a/entc/integration/edgeschema/ent/usertweet_create.go b/entc/integration/edgeschema/ent/usertweet_create.go index eb1d7b6ca..eb64f04b9 100644 --- a/entc/integration/edgeschema/ent/usertweet_create.go +++ b/entc/integration/edgeschema/ent/usertweet_create.go @@ -393,12 +393,16 @@ func (u *UserTweetUpsertOne) IDX(ctx context.Context) int { // UserTweetCreateBulk is the builder for creating many UserTweet entities in bulk. type UserTweetCreateBulk struct { config + err error builders []*UserTweetCreate conflict []sql.ConflictOption } // Save creates the UserTweet entities in the database. func (utcb *UserTweetCreateBulk) Save(ctx context.Context) ([]*UserTweet, error) { + if utcb.err != nil { + return nil, utcb.err + } specs := make([]*sqlgraph.CreateSpec, len(utcb.builders)) nodes := make([]*UserTweet, len(utcb.builders)) mutators := make([]Mutator, len(utcb.builders)) @@ -601,6 +605,9 @@ func (u *UserTweetUpsertBulk) UpdateTweetID() *UserTweetUpsertBulk { // Exec executes the query. func (u *UserTweetUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the UserTweetCreateBulk instead", i) diff --git a/entc/integration/ent/api_create.go b/entc/integration/ent/api_create.go index 323188f13..2983e9fe9 100644 --- a/entc/integration/ent/api_create.go +++ b/entc/integration/ent/api_create.go @@ -208,12 +208,16 @@ func (u *ApiUpsertOne) IDX(ctx context.Context) int { // APICreateBulk is the builder for creating many Api entities in bulk. type APICreateBulk struct { config + err error builders []*APICreate conflict []sql.ConflictOption } // Save creates the Api entities in the database. func (acb *APICreateBulk) Save(ctx context.Context) ([]*Api, error) { + if acb.err != nil { + return nil, acb.err + } specs := make([]*sqlgraph.CreateSpec, len(acb.builders)) nodes := make([]*Api, len(acb.builders)) mutators := make([]Mutator, len(acb.builders)) @@ -368,6 +372,9 @@ func (u *ApiUpsertBulk) Update(set func(*ApiUpsert)) *ApiUpsertBulk { // Exec executes the query. func (u *ApiUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the APICreateBulk instead", i) diff --git a/entc/integration/ent/builder_create.go b/entc/integration/ent/builder_create.go index e7fffc1ef..ac8d003d2 100644 --- a/entc/integration/ent/builder_create.go +++ b/entc/integration/ent/builder_create.go @@ -208,12 +208,16 @@ func (u *BuilderUpsertOne) IDX(ctx context.Context) int { // BuilderCreateBulk is the builder for creating many Builder entities in bulk. type BuilderCreateBulk struct { config + err error builders []*BuilderCreate conflict []sql.ConflictOption } // Save creates the Builder entities in the database. func (bcb *BuilderCreateBulk) Save(ctx context.Context) ([]*Builder, error) { + if bcb.err != nil { + return nil, bcb.err + } specs := make([]*sqlgraph.CreateSpec, len(bcb.builders)) nodes := make([]*Builder, len(bcb.builders)) mutators := make([]Mutator, len(bcb.builders)) @@ -368,6 +372,9 @@ func (u *BuilderUpsertBulk) Update(set func(*BuilderUpsert)) *BuilderUpsertBulk // Exec executes the query. func (u *BuilderUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the BuilderCreateBulk instead", i) diff --git a/entc/integration/ent/card_create.go b/entc/integration/ent/card_create.go index 6294c0ddd..62b0e7a65 100644 --- a/entc/integration/ent/card_create.go +++ b/entc/integration/ent/card_create.go @@ -517,12 +517,16 @@ func (u *CardUpsertOne) IDX(ctx context.Context) int { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate conflict []sql.ConflictOption } // Save creates the Card entities in the database. func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Card, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) @@ -749,6 +753,9 @@ func (u *CardUpsertBulk) ClearName() *CardUpsertBulk { // Exec executes the query. func (u *CardUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the CardCreateBulk instead", i) diff --git a/entc/integration/ent/client.go b/entc/integration/ent/client.go index 018490f17..fb5469e09 100644 --- a/entc/integration/ent/client.go +++ b/entc/integration/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/ent/migrate" @@ -397,6 +398,21 @@ func (c *APIClient) CreateBulk(builders ...*APICreate) *APICreateBulk { return &APICreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *APIClient) MapCreateBulk(slice any, setFunc func(*APICreate, int)) *APICreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &APICreateBulk{err: fmt.Errorf("calling to APIClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*APICreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &APICreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Api. func (c *APIClient) Update() *APIUpdate { mutation := newAPIMutation(c.config, OpUpdate) @@ -515,6 +531,21 @@ func (c *BuilderClient) CreateBulk(builders ...*BuilderCreate) *BuilderCreateBul return &BuilderCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *BuilderClient) MapCreateBulk(slice any, setFunc func(*BuilderCreate, int)) *BuilderCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &BuilderCreateBulk{err: fmt.Errorf("calling to BuilderClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*BuilderCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &BuilderCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Builder. func (c *BuilderClient) Update() *BuilderUpdate { mutation := newBuilderMutation(c.config, OpUpdate) @@ -633,6 +664,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -783,6 +829,21 @@ func (c *CommentClient) CreateBulk(builders ...*CommentCreate) *CommentCreateBul return &CommentCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CommentClient) MapCreateBulk(slice any, setFunc func(*CommentCreate, int)) *CommentCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CommentCreateBulk{err: fmt.Errorf("calling to CommentClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CommentCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CommentCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Comment. func (c *CommentClient) Update() *CommentUpdate { mutation := newCommentMutation(c.config, OpUpdate) @@ -901,6 +962,21 @@ func (c *ExValueScanClient) CreateBulk(builders ...*ExValueScanCreate) *ExValueS return &ExValueScanCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ExValueScanClient) MapCreateBulk(slice any, setFunc func(*ExValueScanCreate, int)) *ExValueScanCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ExValueScanCreateBulk{err: fmt.Errorf("calling to ExValueScanClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ExValueScanCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ExValueScanCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for ExValueScan. func (c *ExValueScanClient) Update() *ExValueScanUpdate { mutation := newExValueScanMutation(c.config, OpUpdate) @@ -1019,6 +1095,21 @@ func (c *FieldTypeClient) CreateBulk(builders ...*FieldTypeCreate) *FieldTypeCre return &FieldTypeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FieldTypeClient) MapCreateBulk(slice any, setFunc func(*FieldTypeCreate, int)) *FieldTypeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FieldTypeCreateBulk{err: fmt.Errorf("calling to FieldTypeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FieldTypeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FieldTypeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for FieldType. func (c *FieldTypeClient) Update() *FieldTypeUpdate { mutation := newFieldTypeMutation(c.config, OpUpdate) @@ -1137,6 +1228,21 @@ func (c *FileClient) CreateBulk(builders ...*FileCreate) *FileCreateBulk { return &FileCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FileClient) MapCreateBulk(slice any, setFunc func(*FileCreate, int)) *FileCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FileCreateBulk{err: fmt.Errorf("calling to FileClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FileCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FileCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for File. func (c *FileClient) Update() *FileUpdate { mutation := newFileMutation(c.config, OpUpdate) @@ -1303,6 +1409,21 @@ func (c *FileTypeClient) CreateBulk(builders ...*FileTypeCreate) *FileTypeCreate return &FileTypeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FileTypeClient) MapCreateBulk(slice any, setFunc func(*FileTypeCreate, int)) *FileTypeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FileTypeCreateBulk{err: fmt.Errorf("calling to FileTypeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FileTypeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FileTypeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for FileType. func (c *FileTypeClient) Update() *FileTypeUpdate { mutation := newFileTypeMutation(c.config, OpUpdate) @@ -1437,6 +1558,21 @@ func (c *GoodsClient) CreateBulk(builders ...*GoodsCreate) *GoodsCreateBulk { return &GoodsCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GoodsClient) MapCreateBulk(slice any, setFunc func(*GoodsCreate, int)) *GoodsCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GoodsCreateBulk{err: fmt.Errorf("calling to GoodsClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GoodsCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GoodsCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Goods. func (c *GoodsClient) Update() *GoodsUpdate { mutation := newGoodsMutation(c.config, OpUpdate) @@ -1555,6 +1691,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -1737,6 +1888,21 @@ func (c *GroupInfoClient) CreateBulk(builders ...*GroupInfoCreate) *GroupInfoCre return &GroupInfoCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupInfoClient) MapCreateBulk(slice any, setFunc func(*GroupInfoCreate, int)) *GroupInfoCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupInfoCreateBulk{err: fmt.Errorf("calling to GroupInfoClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupInfoCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupInfoCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for GroupInfo. func (c *GroupInfoClient) Update() *GroupInfoUpdate { mutation := newGroupInfoMutation(c.config, OpUpdate) @@ -1871,6 +2037,21 @@ func (c *ItemClient) CreateBulk(builders ...*ItemCreate) *ItemCreateBulk { return &ItemCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ItemClient) MapCreateBulk(slice any, setFunc func(*ItemCreate, int)) *ItemCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ItemCreateBulk{err: fmt.Errorf("calling to ItemClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ItemCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ItemCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Item. func (c *ItemClient) Update() *ItemUpdate { mutation := newItemMutation(c.config, OpUpdate) @@ -1989,6 +2170,21 @@ func (c *LicenseClient) CreateBulk(builders ...*LicenseCreate) *LicenseCreateBul return &LicenseCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *LicenseClient) MapCreateBulk(slice any, setFunc func(*LicenseCreate, int)) *LicenseCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &LicenseCreateBulk{err: fmt.Errorf("calling to LicenseClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*LicenseCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &LicenseCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for License. func (c *LicenseClient) Update() *LicenseUpdate { mutation := newLicenseMutation(c.config, OpUpdate) @@ -2107,6 +2303,21 @@ func (c *NodeClient) CreateBulk(builders ...*NodeCreate) *NodeCreateBulk { return &NodeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *NodeClient) MapCreateBulk(slice any, setFunc func(*NodeCreate, int)) *NodeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &NodeCreateBulk{err: fmt.Errorf("calling to NodeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*NodeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &NodeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Node. func (c *NodeClient) Update() *NodeUpdate { mutation := newNodeMutation(c.config, OpUpdate) @@ -2257,6 +2468,21 @@ func (c *PCClient) CreateBulk(builders ...*PCCreate) *PCCreateBulk { return &PCCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PCClient) MapCreateBulk(slice any, setFunc func(*PCCreate, int)) *PCCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PCCreateBulk{err: fmt.Errorf("calling to PCClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PCCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PCCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for PC. func (c *PCClient) Update() *PCUpdate { mutation := newPCMutation(c.config, OpUpdate) @@ -2375,6 +2601,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -2525,6 +2766,21 @@ func (c *SpecClient) CreateBulk(builders ...*SpecCreate) *SpecCreateBulk { return &SpecCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *SpecClient) MapCreateBulk(slice any, setFunc func(*SpecCreate, int)) *SpecCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &SpecCreateBulk{err: fmt.Errorf("calling to SpecClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*SpecCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &SpecCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Spec. func (c *SpecClient) Update() *SpecUpdate { mutation := newSpecMutation(c.config, OpUpdate) @@ -2659,6 +2915,21 @@ func (c *TaskClient) CreateBulk(builders ...*TaskCreate) *TaskCreateBulk { return &TaskCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TaskClient) MapCreateBulk(slice any, setFunc func(*TaskCreate, int)) *TaskCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TaskCreateBulk{err: fmt.Errorf("calling to TaskClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TaskCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TaskCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Task. func (c *TaskClient) Update() *TaskUpdate { mutation := newTaskMutation(c.config, OpUpdate) @@ -2777,6 +3048,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/ent/comment_create.go b/entc/integration/ent/comment_create.go index dcb2f79b4..38e60fcaf 100644 --- a/entc/integration/ent/comment_create.go +++ b/entc/integration/ent/comment_create.go @@ -560,12 +560,16 @@ func (u *CommentUpsertOne) IDX(ctx context.Context) int { // CommentCreateBulk is the builder for creating many Comment entities in bulk. type CommentCreateBulk struct { config + err error builders []*CommentCreate conflict []sql.ConflictOption } // Save creates the Comment entities in the database. func (ccb *CommentCreateBulk) Save(ctx context.Context) ([]*Comment, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Comment, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) @@ -858,6 +862,9 @@ func (u *CommentUpsertBulk) ClearClient() *CommentUpsertBulk { // Exec executes the query. func (u *CommentUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the CommentCreateBulk instead", i) diff --git a/entc/integration/ent/exvaluescan_create.go b/entc/integration/ent/exvaluescan_create.go index 59e917b7e..0d7855570 100644 --- a/entc/integration/ent/exvaluescan_create.go +++ b/entc/integration/ent/exvaluescan_create.go @@ -558,12 +558,16 @@ func (u *ExValueScanUpsertOne) IDX(ctx context.Context) int { // ExValueScanCreateBulk is the builder for creating many ExValueScan entities in bulk. type ExValueScanCreateBulk struct { config + err error builders []*ExValueScanCreate conflict []sql.ConflictOption } // Save creates the ExValueScan entities in the database. func (evscb *ExValueScanCreateBulk) Save(ctx context.Context) ([]*ExValueScan, error) { + if evscb.err != nil { + return nil, evscb.err + } specs := make([]*sqlgraph.CreateSpec, len(evscb.builders)) nodes := make([]*ExValueScan, len(evscb.builders)) mutators := make([]Mutator, len(evscb.builders)) @@ -845,6 +849,9 @@ func (u *ExValueScanUpsertBulk) ClearCustomOptional() *ExValueScanUpsertBulk { // Exec executes the query. func (u *ExValueScanUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the ExValueScanCreateBulk instead", i) diff --git a/entc/integration/ent/fieldtype_create.go b/entc/integration/ent/fieldtype_create.go index 8e9477459..c62ec7096 100644 --- a/entc/integration/ent/fieldtype_create.go +++ b/entc/integration/ent/fieldtype_create.go @@ -4170,12 +4170,16 @@ func (u *FieldTypeUpsertOne) IDX(ctx context.Context) int { // FieldTypeCreateBulk is the builder for creating many FieldType entities in bulk. type FieldTypeCreateBulk struct { config + err error builders []*FieldTypeCreate conflict []sql.ConflictOption } // Save creates the FieldType entities in the database. func (ftcb *FieldTypeCreateBulk) Save(ctx context.Context) ([]*FieldType, error) { + if ftcb.err != nil { + return nil, ftcb.err + } specs := make([]*sqlgraph.CreateSpec, len(ftcb.builders)) nodes := make([]*FieldType, len(ftcb.builders)) mutators := make([]Mutator, len(ftcb.builders)) @@ -5848,6 +5852,9 @@ func (u *FieldTypeUpsertBulk) ClearPasswordOther() *FieldTypeUpsertBulk { // Exec executes the query. func (u *FieldTypeUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the FieldTypeCreateBulk instead", i) diff --git a/entc/integration/ent/file_create.go b/entc/integration/ent/file_create.go index 3edef8376..7f749ee57 100644 --- a/entc/integration/ent/file_create.go +++ b/entc/integration/ent/file_create.go @@ -674,12 +674,16 @@ func (u *FileUpsertOne) IDX(ctx context.Context) int { // FileCreateBulk is the builder for creating many File entities in bulk. type FileCreateBulk struct { config + err error builders []*FileCreate conflict []sql.ConflictOption } // Save creates the File entities in the database. func (fcb *FileCreateBulk) Save(ctx context.Context) ([]*File, error) { + if fcb.err != nil { + return nil, fcb.err + } specs := make([]*sqlgraph.CreateSpec, len(fcb.builders)) nodes := make([]*File, len(fcb.builders)) mutators := make([]Mutator, len(fcb.builders)) @@ -966,6 +970,9 @@ func (u *FileUpsertBulk) ClearFieldID() *FileUpsertBulk { // Exec executes the query. func (u *FileUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the FileCreateBulk instead", i) diff --git a/entc/integration/ent/filetype_create.go b/entc/integration/ent/filetype_create.go index 3ca7f2bba..a13c6fd7f 100644 --- a/entc/integration/ent/filetype_create.go +++ b/entc/integration/ent/filetype_create.go @@ -402,12 +402,16 @@ func (u *FileTypeUpsertOne) IDX(ctx context.Context) int { // FileTypeCreateBulk is the builder for creating many FileType entities in bulk. type FileTypeCreateBulk struct { config + err error builders []*FileTypeCreate conflict []sql.ConflictOption } // Save creates the FileType entities in the database. func (ftcb *FileTypeCreateBulk) Save(ctx context.Context) ([]*FileType, error) { + if ftcb.err != nil { + return nil, ftcb.err + } specs := make([]*sqlgraph.CreateSpec, len(ftcb.builders)) nodes := make([]*FileType, len(ftcb.builders)) mutators := make([]Mutator, len(ftcb.builders)) @@ -610,6 +614,9 @@ func (u *FileTypeUpsertBulk) UpdateState() *FileTypeUpsertBulk { // Exec executes the query. func (u *FileTypeUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the FileTypeCreateBulk instead", i) diff --git a/entc/integration/ent/goods_create.go b/entc/integration/ent/goods_create.go index 09fa26c3a..95d879ee8 100644 --- a/entc/integration/ent/goods_create.go +++ b/entc/integration/ent/goods_create.go @@ -208,12 +208,16 @@ func (u *GoodsUpsertOne) IDX(ctx context.Context) int { // GoodsCreateBulk is the builder for creating many Goods entities in bulk. type GoodsCreateBulk struct { config + err error builders []*GoodsCreate conflict []sql.ConflictOption } // Save creates the Goods entities in the database. func (gcb *GoodsCreateBulk) Save(ctx context.Context) ([]*Goods, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Goods, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) @@ -368,6 +372,9 @@ func (u *GoodsUpsertBulk) Update(set func(*GoodsUpsert)) *GoodsUpsertBulk { // Exec executes the query. func (u *GoodsUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the GoodsCreateBulk instead", i) diff --git a/entc/integration/ent/group_create.go b/entc/integration/ent/group_create.go index b24e091cc..7c6cd8696 100644 --- a/entc/integration/ent/group_create.go +++ b/entc/integration/ent/group_create.go @@ -622,12 +622,16 @@ func (u *GroupUpsertOne) IDX(ctx context.Context) int { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate conflict []sql.ConflictOption } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) @@ -879,6 +883,9 @@ func (u *GroupUpsertBulk) UpdateName() *GroupUpsertBulk { // Exec executes the query. func (u *GroupUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the GroupCreateBulk instead", i) diff --git a/entc/integration/ent/groupinfo_create.go b/entc/integration/ent/groupinfo_create.go index e8831bb50..0ae1e57d1 100644 --- a/entc/integration/ent/groupinfo_create.go +++ b/entc/integration/ent/groupinfo_create.go @@ -354,12 +354,16 @@ func (u *GroupInfoUpsertOne) IDX(ctx context.Context) int { // GroupInfoCreateBulk is the builder for creating many GroupInfo entities in bulk. type GroupInfoCreateBulk struct { config + err error builders []*GroupInfoCreate conflict []sql.ConflictOption } // Save creates the GroupInfo entities in the database. func (gicb *GroupInfoCreateBulk) Save(ctx context.Context) ([]*GroupInfo, error) { + if gicb.err != nil { + return nil, gicb.err + } specs := make([]*sqlgraph.CreateSpec, len(gicb.builders)) nodes := make([]*GroupInfo, len(gicb.builders)) mutators := make([]Mutator, len(gicb.builders)) @@ -555,6 +559,9 @@ func (u *GroupInfoUpsertBulk) UpdateMaxUsers() *GroupInfoUpsertBulk { // Exec executes the query. func (u *GroupInfoUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the GroupInfoCreateBulk instead", i) diff --git a/entc/integration/ent/item_create.go b/entc/integration/ent/item_create.go index 7c123aef9..b5a9a9380 100644 --- a/entc/integration/ent/item_create.go +++ b/entc/integration/ent/item_create.go @@ -327,12 +327,16 @@ func (u *ItemUpsertOne) IDX(ctx context.Context) string { // ItemCreateBulk is the builder for creating many Item entities in bulk. type ItemCreateBulk struct { config + err error builders []*ItemCreate conflict []sql.ConflictOption } // Save creates the Item entities in the database. func (icb *ItemCreateBulk) Save(ctx context.Context) ([]*Item, error) { + if icb.err != nil { + return nil, icb.err + } specs := make([]*sqlgraph.CreateSpec, len(icb.builders)) nodes := make([]*Item, len(icb.builders)) mutators := make([]Mutator, len(icb.builders)) @@ -520,6 +524,9 @@ func (u *ItemUpsertBulk) ClearText() *ItemUpsertBulk { // Exec executes the query. func (u *ItemUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the ItemCreateBulk instead", i) diff --git a/entc/integration/ent/license_create.go b/entc/integration/ent/license_create.go index 12e879431..cb6c00e89 100644 --- a/entc/integration/ent/license_create.go +++ b/entc/integration/ent/license_create.go @@ -319,12 +319,16 @@ func (u *LicenseUpsertOne) IDX(ctx context.Context) int { // LicenseCreateBulk is the builder for creating many License entities in bulk. type LicenseCreateBulk struct { config + err error builders []*LicenseCreate conflict []sql.ConflictOption } // Save creates the License entities in the database. func (lcb *LicenseCreateBulk) Save(ctx context.Context) ([]*License, error) { + if lcb.err != nil { + return nil, lcb.err + } specs := make([]*sqlgraph.CreateSpec, len(lcb.builders)) nodes := make([]*License, len(lcb.builders)) mutators := make([]Mutator, len(lcb.builders)) @@ -512,6 +516,9 @@ func (u *LicenseUpsertBulk) UpdateUpdateTime() *LicenseUpsertBulk { // Exec executes the query. func (u *LicenseUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the LicenseCreateBulk instead", i) diff --git a/entc/integration/ent/node_create.go b/entc/integration/ent/node_create.go index 922a4e109..2528775d9 100644 --- a/entc/integration/ent/node_create.go +++ b/entc/integration/ent/node_create.go @@ -413,12 +413,16 @@ func (u *NodeUpsertOne) IDX(ctx context.Context) int { // NodeCreateBulk is the builder for creating many Node entities in bulk. type NodeCreateBulk struct { config + err error builders []*NodeCreate conflict []sql.ConflictOption } // Save creates the Node entities in the database. func (ncb *NodeCreateBulk) Save(ctx context.Context) ([]*Node, error) { + if ncb.err != nil { + return nil, ncb.err + } specs := make([]*sqlgraph.CreateSpec, len(ncb.builders)) nodes := make([]*Node, len(ncb.builders)) mutators := make([]Mutator, len(ncb.builders)) @@ -627,6 +631,9 @@ func (u *NodeUpsertBulk) ClearUpdatedAt() *NodeUpsertBulk { // Exec executes the query. func (u *NodeUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the NodeCreateBulk instead", i) diff --git a/entc/integration/ent/pc_create.go b/entc/integration/ent/pc_create.go index 19974bf54..68575b9eb 100644 --- a/entc/integration/ent/pc_create.go +++ b/entc/integration/ent/pc_create.go @@ -208,12 +208,16 @@ func (u *PCUpsertOne) IDX(ctx context.Context) int { // PCCreateBulk is the builder for creating many PC entities in bulk. type PCCreateBulk struct { config + err error builders []*PCCreate conflict []sql.ConflictOption } // Save creates the PC entities in the database. func (pcb *PCCreateBulk) Save(ctx context.Context) ([]*PC, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*PC, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) @@ -368,6 +372,9 @@ func (u *PCUpsertBulk) Update(set func(*PCUpsert)) *PCUpsertBulk { // Exec executes the query. func (u *PCUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the PCCreateBulk instead", i) diff --git a/entc/integration/ent/pet_create.go b/entc/integration/ent/pet_create.go index 663769e2b..21d06f62c 100644 --- a/entc/integration/ent/pet_create.go +++ b/entc/integration/ent/pet_create.go @@ -561,12 +561,16 @@ func (u *PetUpsertOne) IDX(ctx context.Context) int { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate conflict []sql.ConflictOption } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) @@ -818,6 +822,9 @@ func (u *PetUpsertBulk) UpdateTrained() *PetUpsertBulk { // Exec executes the query. func (u *PetUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the PetCreateBulk instead", i) diff --git a/entc/integration/ent/spec_create.go b/entc/integration/ent/spec_create.go index 42d411b70..8dd9c531e 100644 --- a/entc/integration/ent/spec_create.go +++ b/entc/integration/ent/spec_create.go @@ -240,12 +240,16 @@ func (u *SpecUpsertOne) IDX(ctx context.Context) int { // SpecCreateBulk is the builder for creating many Spec entities in bulk. type SpecCreateBulk struct { config + err error builders []*SpecCreate conflict []sql.ConflictOption } // Save creates the Spec entities in the database. func (scb *SpecCreateBulk) Save(ctx context.Context) ([]*Spec, error) { + if scb.err != nil { + return nil, scb.err + } specs := make([]*sqlgraph.CreateSpec, len(scb.builders)) nodes := make([]*Spec, len(scb.builders)) mutators := make([]Mutator, len(scb.builders)) @@ -400,6 +404,9 @@ func (u *SpecUpsertBulk) Update(set func(*SpecUpsert)) *SpecUpsertBulk { // Exec executes the query. func (u *SpecUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the SpecCreateBulk instead", i) diff --git a/entc/integration/ent/task_create.go b/entc/integration/ent/task_create.go index 113e4ca12..75ed3a6d1 100644 --- a/entc/integration/ent/task_create.go +++ b/entc/integration/ent/task_create.go @@ -679,12 +679,16 @@ func (u *TaskUpsertOne) IDX(ctx context.Context) int { // TaskCreateBulk is the builder for creating many Task entities in bulk. type TaskCreateBulk struct { config + err error builders []*TaskCreate conflict []sql.ConflictOption } // Save creates the Task entities in the database. func (tcb *TaskCreateBulk) Save(ctx context.Context) ([]*Task, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Task, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) @@ -1006,6 +1010,9 @@ func (u *TaskUpsertBulk) UpdateOp() *TaskUpsertBulk { // Exec executes the query. func (u *TaskUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the TaskCreateBulk instead", i) diff --git a/entc/integration/ent/user_create.go b/entc/integration/ent/user_create.go index 7ee77fee2..6d193c831 100644 --- a/entc/integration/ent/user_create.go +++ b/entc/integration/ent/user_create.go @@ -1270,12 +1270,16 @@ func (u *UserUpsertOne) IDX(ctx context.Context) int { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate conflict []sql.ConflictOption } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) @@ -1674,6 +1678,9 @@ func (u *UserUpsertBulk) ClearFilesCount() *UserUpsertBulk { // Exec executes the query. func (u *UserUpsertBulk) Exec(ctx context.Context) error { + if u.create.err != nil { + return u.create.err + } for i, b := range u.create.builders { if len(b.conflict) != 0 { return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the UserCreateBulk instead", i) diff --git a/entc/integration/gremlin/ent/api_create.go b/entc/integration/gremlin/ent/api_create.go index 818bbbcba..630624d97 100644 --- a/entc/integration/gremlin/ent/api_create.go +++ b/entc/integration/gremlin/ent/api_create.go @@ -88,5 +88,6 @@ func (ac *APICreate) gremlin() *dsl.Traversal { // APICreateBulk is the builder for creating many Api entities in bulk. type APICreateBulk struct { config + err error builders []*APICreate } diff --git a/entc/integration/gremlin/ent/builder_create.go b/entc/integration/gremlin/ent/builder_create.go index 99df70ebc..fa54843c5 100644 --- a/entc/integration/gremlin/ent/builder_create.go +++ b/entc/integration/gremlin/ent/builder_create.go @@ -88,5 +88,6 @@ func (bc *BuilderCreate) gremlin() *dsl.Traversal { // BuilderCreateBulk is the builder for creating many Builder entities in bulk. type BuilderCreateBulk struct { config + err error builders []*BuilderCreate } diff --git a/entc/integration/gremlin/ent/card_create.go b/entc/integration/gremlin/ent/card_create.go index e70f66292..5db0de23b 100644 --- a/entc/integration/gremlin/ent/card_create.go +++ b/entc/integration/gremlin/ent/card_create.go @@ -267,5 +267,6 @@ func (cc *CardCreate) gremlin() *dsl.Traversal { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate } diff --git a/entc/integration/gremlin/ent/client.go b/entc/integration/gremlin/ent/client.go index d90d9d127..5ae60c1e2 100644 --- a/entc/integration/gremlin/ent/client.go +++ b/entc/integration/gremlin/ent/client.go @@ -12,6 +12,7 @@ import ( "fmt" "log" "net/url" + "reflect" "entgo.io/ent" "entgo.io/ent/dialect" @@ -363,6 +364,21 @@ func (c *APIClient) CreateBulk(builders ...*APICreate) *APICreateBulk { return &APICreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *APIClient) MapCreateBulk(slice any, setFunc func(*APICreate, int)) *APICreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &APICreateBulk{err: fmt.Errorf("calling to APIClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*APICreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &APICreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Api. func (c *APIClient) Update() *APIUpdate { mutation := newAPIMutation(c.config, OpUpdate) @@ -481,6 +497,21 @@ func (c *BuilderClient) CreateBulk(builders ...*BuilderCreate) *BuilderCreateBul return &BuilderCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *BuilderClient) MapCreateBulk(slice any, setFunc func(*BuilderCreate, int)) *BuilderCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &BuilderCreateBulk{err: fmt.Errorf("calling to BuilderClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*BuilderCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &BuilderCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Builder. func (c *BuilderClient) Update() *BuilderUpdate { mutation := newBuilderMutation(c.config, OpUpdate) @@ -599,6 +630,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -739,6 +785,21 @@ func (c *CommentClient) CreateBulk(builders ...*CommentCreate) *CommentCreateBul return &CommentCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CommentClient) MapCreateBulk(slice any, setFunc func(*CommentCreate, int)) *CommentCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CommentCreateBulk{err: fmt.Errorf("calling to CommentClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CommentCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CommentCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Comment. func (c *CommentClient) Update() *CommentUpdate { mutation := newCommentMutation(c.config, OpUpdate) @@ -857,6 +918,21 @@ func (c *ExValueScanClient) CreateBulk(builders ...*ExValueScanCreate) *ExValueS return &ExValueScanCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ExValueScanClient) MapCreateBulk(slice any, setFunc func(*ExValueScanCreate, int)) *ExValueScanCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ExValueScanCreateBulk{err: fmt.Errorf("calling to ExValueScanClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ExValueScanCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ExValueScanCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for ExValueScan. func (c *ExValueScanClient) Update() *ExValueScanUpdate { mutation := newExValueScanMutation(c.config, OpUpdate) @@ -975,6 +1051,21 @@ func (c *FieldTypeClient) CreateBulk(builders ...*FieldTypeCreate) *FieldTypeCre return &FieldTypeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FieldTypeClient) MapCreateBulk(slice any, setFunc func(*FieldTypeCreate, int)) *FieldTypeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FieldTypeCreateBulk{err: fmt.Errorf("calling to FieldTypeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FieldTypeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FieldTypeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for FieldType. func (c *FieldTypeClient) Update() *FieldTypeUpdate { mutation := newFieldTypeMutation(c.config, OpUpdate) @@ -1093,6 +1184,21 @@ func (c *FileClient) CreateBulk(builders ...*FileCreate) *FileCreateBulk { return &FileCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FileClient) MapCreateBulk(slice any, setFunc func(*FileCreate, int)) *FileCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FileCreateBulk{err: fmt.Errorf("calling to FileClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FileCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FileCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for File. func (c *FileClient) Update() *FileUpdate { mutation := newFileMutation(c.config, OpUpdate) @@ -1244,6 +1350,21 @@ func (c *FileTypeClient) CreateBulk(builders ...*FileTypeCreate) *FileTypeCreate return &FileTypeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FileTypeClient) MapCreateBulk(slice any, setFunc func(*FileTypeCreate, int)) *FileTypeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FileTypeCreateBulk{err: fmt.Errorf("calling to FileTypeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FileTypeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FileTypeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for FileType. func (c *FileTypeClient) Update() *FileTypeUpdate { mutation := newFileTypeMutation(c.config, OpUpdate) @@ -1373,6 +1494,21 @@ func (c *GoodsClient) CreateBulk(builders ...*GoodsCreate) *GoodsCreateBulk { return &GoodsCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GoodsClient) MapCreateBulk(slice any, setFunc func(*GoodsCreate, int)) *GoodsCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GoodsCreateBulk{err: fmt.Errorf("calling to GoodsClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GoodsCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GoodsCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Goods. func (c *GoodsClient) Update() *GoodsUpdate { mutation := newGoodsMutation(c.config, OpUpdate) @@ -1491,6 +1627,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -1653,6 +1804,21 @@ func (c *GroupInfoClient) CreateBulk(builders ...*GroupInfoCreate) *GroupInfoCre return &GroupInfoCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupInfoClient) MapCreateBulk(slice any, setFunc func(*GroupInfoCreate, int)) *GroupInfoCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupInfoCreateBulk{err: fmt.Errorf("calling to GroupInfoClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupInfoCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupInfoCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for GroupInfo. func (c *GroupInfoClient) Update() *GroupInfoUpdate { mutation := newGroupInfoMutation(c.config, OpUpdate) @@ -1782,6 +1948,21 @@ func (c *ItemClient) CreateBulk(builders ...*ItemCreate) *ItemCreateBulk { return &ItemCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ItemClient) MapCreateBulk(slice any, setFunc func(*ItemCreate, int)) *ItemCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ItemCreateBulk{err: fmt.Errorf("calling to ItemClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ItemCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ItemCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Item. func (c *ItemClient) Update() *ItemUpdate { mutation := newItemMutation(c.config, OpUpdate) @@ -1900,6 +2081,21 @@ func (c *LicenseClient) CreateBulk(builders ...*LicenseCreate) *LicenseCreateBul return &LicenseCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *LicenseClient) MapCreateBulk(slice any, setFunc func(*LicenseCreate, int)) *LicenseCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &LicenseCreateBulk{err: fmt.Errorf("calling to LicenseClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*LicenseCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &LicenseCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for License. func (c *LicenseClient) Update() *LicenseUpdate { mutation := newLicenseMutation(c.config, OpUpdate) @@ -2018,6 +2214,21 @@ func (c *NodeClient) CreateBulk(builders ...*NodeCreate) *NodeCreateBulk { return &NodeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *NodeClient) MapCreateBulk(slice any, setFunc func(*NodeCreate, int)) *NodeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &NodeCreateBulk{err: fmt.Errorf("calling to NodeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*NodeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &NodeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Node. func (c *NodeClient) Update() *NodeUpdate { mutation := newNodeMutation(c.config, OpUpdate) @@ -2158,6 +2369,21 @@ func (c *PCClient) CreateBulk(builders ...*PCCreate) *PCCreateBulk { return &PCCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PCClient) MapCreateBulk(slice any, setFunc func(*PCCreate, int)) *PCCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PCCreateBulk{err: fmt.Errorf("calling to PCClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PCCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PCCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for PC. func (c *PCClient) Update() *PCUpdate { mutation := newPCMutation(c.config, OpUpdate) @@ -2276,6 +2502,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -2416,6 +2657,21 @@ func (c *SpecClient) CreateBulk(builders ...*SpecCreate) *SpecCreateBulk { return &SpecCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *SpecClient) MapCreateBulk(slice any, setFunc func(*SpecCreate, int)) *SpecCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &SpecCreateBulk{err: fmt.Errorf("calling to SpecClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*SpecCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &SpecCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Spec. func (c *SpecClient) Update() *SpecUpdate { mutation := newSpecMutation(c.config, OpUpdate) @@ -2545,6 +2801,21 @@ func (c *TaskClient) CreateBulk(builders ...*TaskCreate) *TaskCreateBulk { return &TaskCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TaskClient) MapCreateBulk(slice any, setFunc func(*TaskCreate, int)) *TaskCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TaskCreateBulk{err: fmt.Errorf("calling to TaskClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TaskCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TaskCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Task. func (c *TaskClient) Update() *TaskUpdate { mutation := newTaskMutation(c.config, OpUpdate) @@ -2663,6 +2934,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/gremlin/ent/comment_create.go b/entc/integration/gremlin/ent/comment_create.go index 6dc8bd672..f181fcaf9 100644 --- a/entc/integration/gremlin/ent/comment_create.go +++ b/entc/integration/gremlin/ent/comment_create.go @@ -204,5 +204,6 @@ func (cc *CommentCreate) gremlin() *dsl.Traversal { // CommentCreateBulk is the builder for creating many Comment entities in bulk. type CommentCreateBulk struct { config + err error builders []*CommentCreate } diff --git a/entc/integration/gremlin/ent/exvaluescan_create.go b/entc/integration/gremlin/ent/exvaluescan_create.go index 53b7ea5e4..bc9f28787 100644 --- a/entc/integration/gremlin/ent/exvaluescan_create.go +++ b/entc/integration/gremlin/ent/exvaluescan_create.go @@ -174,5 +174,6 @@ func (evsc *ExValueScanCreate) gremlin() *dsl.Traversal { // ExValueScanCreateBulk is the builder for creating many ExValueScan entities in bulk. type ExValueScanCreateBulk struct { config + err error builders []*ExValueScanCreate } diff --git a/entc/integration/gremlin/ent/fieldtype_create.go b/entc/integration/gremlin/ent/fieldtype_create.go index c3901a7e7..d44f8df9b 100644 --- a/entc/integration/gremlin/ent/fieldtype_create.go +++ b/entc/integration/gremlin/ent/fieldtype_create.go @@ -1174,5 +1174,6 @@ func (ftc *FieldTypeCreate) gremlin() *dsl.Traversal { // FieldTypeCreateBulk is the builder for creating many FieldType entities in bulk. type FieldTypeCreateBulk struct { config + err error builders []*FieldTypeCreate } diff --git a/entc/integration/gremlin/ent/file_create.go b/entc/integration/gremlin/ent/file_create.go index c9dde34a5..7819503ef 100644 --- a/entc/integration/gremlin/ent/file_create.go +++ b/entc/integration/gremlin/ent/file_create.go @@ -286,5 +286,6 @@ func (fc *FileCreate) gremlin() *dsl.Traversal { // FileCreateBulk is the builder for creating many File entities in bulk. type FileCreateBulk struct { config + err error builders []*FileCreate } diff --git a/entc/integration/gremlin/ent/filetype_create.go b/entc/integration/gremlin/ent/filetype_create.go index 289ab3da8..f4e484995 100644 --- a/entc/integration/gremlin/ent/filetype_create.go +++ b/entc/integration/gremlin/ent/filetype_create.go @@ -205,5 +205,6 @@ func (ftc *FileTypeCreate) gremlin() *dsl.Traversal { // FileTypeCreateBulk is the builder for creating many FileType entities in bulk. type FileTypeCreateBulk struct { config + err error builders []*FileTypeCreate } diff --git a/entc/integration/gremlin/ent/goods_create.go b/entc/integration/gremlin/ent/goods_create.go index 42bb9f8c7..fa9cb0de9 100644 --- a/entc/integration/gremlin/ent/goods_create.go +++ b/entc/integration/gremlin/ent/goods_create.go @@ -88,5 +88,6 @@ func (gc *GoodsCreate) gremlin() *dsl.Traversal { // GoodsCreateBulk is the builder for creating many Goods entities in bulk. type GoodsCreateBulk struct { config + err error builders []*GoodsCreate } diff --git a/entc/integration/gremlin/ent/group_create.go b/entc/integration/gremlin/ent/group_create.go index 30244eba4..29e4ad900 100644 --- a/entc/integration/gremlin/ent/group_create.go +++ b/entc/integration/gremlin/ent/group_create.go @@ -291,5 +291,6 @@ func (gc *GroupCreate) gremlin() *dsl.Traversal { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } diff --git a/entc/integration/gremlin/ent/groupinfo_create.go b/entc/integration/gremlin/ent/groupinfo_create.go index e250d803f..8ad82aa91 100644 --- a/entc/integration/gremlin/ent/groupinfo_create.go +++ b/entc/integration/gremlin/ent/groupinfo_create.go @@ -167,5 +167,6 @@ func (gic *GroupInfoCreate) gremlin() *dsl.Traversal { // GroupInfoCreateBulk is the builder for creating many GroupInfo entities in bulk. type GroupInfoCreateBulk struct { config + err error builders []*GroupInfoCreate } diff --git a/entc/integration/gremlin/ent/item_create.go b/entc/integration/gremlin/ent/item_create.go index ad9aa13a7..4f257c68d 100644 --- a/entc/integration/gremlin/ent/item_create.go +++ b/entc/integration/gremlin/ent/item_create.go @@ -160,5 +160,6 @@ func (ic *ItemCreate) gremlin() *dsl.Traversal { // ItemCreateBulk is the builder for creating many Item entities in bulk. type ItemCreateBulk struct { config + err error builders []*ItemCreate } diff --git a/entc/integration/gremlin/ent/license_create.go b/entc/integration/gremlin/ent/license_create.go index 41ee7eaf9..166a22877 100644 --- a/entc/integration/gremlin/ent/license_create.go +++ b/entc/integration/gremlin/ent/license_create.go @@ -152,5 +152,6 @@ func (lc *LicenseCreate) gremlin() *dsl.Traversal { // LicenseCreateBulk is the builder for creating many License entities in bulk. type LicenseCreateBulk struct { config + err error builders []*LicenseCreate } diff --git a/entc/integration/gremlin/ent/node_create.go b/entc/integration/gremlin/ent/node_create.go index 2cd4995cf..24e663449 100644 --- a/entc/integration/gremlin/ent/node_create.go +++ b/entc/integration/gremlin/ent/node_create.go @@ -189,5 +189,6 @@ func (nc *NodeCreate) gremlin() *dsl.Traversal { // NodeCreateBulk is the builder for creating many Node entities in bulk. type NodeCreateBulk struct { config + err error builders []*NodeCreate } diff --git a/entc/integration/gremlin/ent/pc_create.go b/entc/integration/gremlin/ent/pc_create.go index 7c589cb95..248a0efa3 100644 --- a/entc/integration/gremlin/ent/pc_create.go +++ b/entc/integration/gremlin/ent/pc_create.go @@ -88,5 +88,6 @@ func (_pc *PCCreate) gremlin() *dsl.Traversal { // PCCreateBulk is the builder for creating many PC entities in bulk. type PCCreateBulk struct { config + err error builders []*PCCreate } diff --git a/entc/integration/gremlin/ent/pet_create.go b/entc/integration/gremlin/ent/pet_create.go index a72b77162..42acf6aa0 100644 --- a/entc/integration/gremlin/ent/pet_create.go +++ b/entc/integration/gremlin/ent/pet_create.go @@ -252,5 +252,6 @@ func (pc *PetCreate) gremlin() *dsl.Traversal { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } diff --git a/entc/integration/gremlin/ent/spec_create.go b/entc/integration/gremlin/ent/spec_create.go index 77f827452..5bddafcdf 100644 --- a/entc/integration/gremlin/ent/spec_create.go +++ b/entc/integration/gremlin/ent/spec_create.go @@ -106,5 +106,6 @@ func (sc *SpecCreate) gremlin() *dsl.Traversal { // SpecCreateBulk is the builder for creating many Spec entities in bulk. type SpecCreateBulk struct { config + err error builders []*SpecCreate } diff --git a/entc/integration/gremlin/ent/task_create.go b/entc/integration/gremlin/ent/task_create.go index ba83b6ee3..998ec1e75 100644 --- a/entc/integration/gremlin/ent/task_create.go +++ b/entc/integration/gremlin/ent/task_create.go @@ -256,5 +256,6 @@ func (tc *TaskCreate) gremlin() *dsl.Traversal { // TaskCreateBulk is the builder for creating many Task entities in bulk. type TaskCreateBulk struct { config + err error builders []*TaskCreate } diff --git a/entc/integration/gremlin/ent/user_create.go b/entc/integration/gremlin/ent/user_create.go index 0711e4442..f55f55303 100644 --- a/entc/integration/gremlin/ent/user_create.go +++ b/entc/integration/gremlin/ent/user_create.go @@ -589,5 +589,6 @@ func (uc *UserCreate) gremlin() *dsl.Traversal { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } diff --git a/entc/integration/hooks/ent/card_create.go b/entc/integration/hooks/ent/card_create.go index 47c573b34..2f19f0cf2 100644 --- a/entc/integration/hooks/ent/card_create.go +++ b/entc/integration/hooks/ent/card_create.go @@ -242,11 +242,15 @@ func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate } // Save creates the Card entities in the database. func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Card, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/hooks/ent/client.go b/entc/integration/hooks/ent/client.go index 368a43916..d702f5935 100644 --- a/entc/integration/hooks/ent/client.go +++ b/entc/integration/hooks/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/hooks/ent/migrate" @@ -248,6 +249,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -384,6 +400,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -520,6 +551,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/hooks/ent/pet_create.go b/entc/integration/hooks/ent/pet_create.go index 7ca843488..f43f587bf 100644 --- a/entc/integration/hooks/ent/pet_create.go +++ b/entc/integration/hooks/ent/pet_create.go @@ -162,11 +162,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/hooks/ent/user_create.go b/entc/integration/hooks/ent/user_create.go index 1273e0ddb..d8a72e068 100644 --- a/entc/integration/hooks/ent/user_create.go +++ b/entc/integration/hooks/ent/user_create.go @@ -327,11 +327,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/idtype/ent/client.go b/entc/integration/idtype/ent/client.go index cfbf14644..222dd6684 100644 --- a/entc/integration/idtype/ent/client.go +++ b/entc/integration/idtype/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/idtype/ent/migrate" @@ -228,6 +229,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/idtype/ent/user_create.go b/entc/integration/idtype/ent/user_create.go index cf91cf03f..182de59b3 100644 --- a/entc/integration/idtype/ent/user_create.go +++ b/entc/integration/idtype/ent/user_create.go @@ -200,11 +200,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/integration_test.go b/entc/integration/integration_test.go index c834e27b5..34c2b26c3 100644 --- a/entc/integration/integration_test.go +++ b/entc/integration/integration_test.go @@ -2218,13 +2218,16 @@ func CreateBulk(t *testing.T, client *ent.Client) { require.Equal(t, cards[1].ID, cards[2].ID-1) inf := client.GroupInfo.Create().SetDesc("group info").SaveX(ctx) - groups := client.Group.CreateBulk( - client.Group.Create().SetName("Github").SetExpire(time.Now()).SetInfo(inf), - client.Group.Create().SetName("GitLab").SetExpire(time.Now()).SetInfo(inf), - ).SaveX(ctx) + names := []string{"GitHub", "GitLab"} + groups := client.Group.MapCreateBulk(names, func(c *ent.GroupCreate, i int) { + c.SetName(names[i]).SetExpire(time.Now()).SetInfo(inf) + }).SaveX(ctx) require.Equal(t, inf.ID, groups[0].QueryInfo().OnlyIDX(ctx)) require.Equal(t, inf.ID, groups[1].QueryInfo().OnlyIDX(ctx)) + _, err := client.Group.MapCreateBulk(1, nil).Save(ctx) + require.Error(t, err) + client.User.Use( func(next ent.Mutator) ent.Mutator { return hook.UserFunc(func(ctx context.Context, m *ent.UserMutation) (ent.Value, error) { diff --git a/entc/integration/json/ent/client.go b/entc/integration/json/ent/client.go index 6c40bbc47..8873b2f9c 100644 --- a/entc/integration/json/ent/client.go +++ b/entc/integration/json/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/json/ent/migrate" @@ -227,6 +228,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/json/ent/user_create.go b/entc/integration/json/ent/user_create.go index 7da3c083d..579d33bb0 100644 --- a/entc/integration/json/ent/user_create.go +++ b/entc/integration/json/ent/user_create.go @@ -262,11 +262,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/migrate/entv1/car_create.go b/entc/integration/migrate/entv1/car_create.go index 62d57d9fb..33e071b11 100644 --- a/entc/integration/migrate/entv1/car_create.go +++ b/entc/integration/migrate/entv1/car_create.go @@ -125,11 +125,15 @@ func (cc *CarCreate) createSpec() (*Car, *sqlgraph.CreateSpec) { // CarCreateBulk is the builder for creating many Car entities in bulk. type CarCreateBulk struct { config + err error builders []*CarCreate } // Save creates the Car entities in the database. func (ccb *CarCreateBulk) Save(ctx context.Context) ([]*Car, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Car, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/migrate/entv1/client.go b/entc/integration/migrate/entv1/client.go index c82bfad73..b690b45cc 100644 --- a/entc/integration/migrate/entv1/client.go +++ b/entc/integration/migrate/entv1/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/migrate/entv1/migrate" @@ -258,6 +259,21 @@ func (c *CarClient) CreateBulk(builders ...*CarCreate) *CarCreateBulk { return &CarCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CarClient) MapCreateBulk(slice any, setFunc func(*CarCreate, int)) *CarCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CarCreateBulk{err: fmt.Errorf("calling to CarClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CarCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CarCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Car. func (c *CarClient) Update() *CarUpdate { mutation := newCarMutation(c.config, OpUpdate) @@ -392,6 +408,21 @@ func (c *ConversionClient) CreateBulk(builders ...*ConversionCreate) *Conversion return &ConversionCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ConversionClient) MapCreateBulk(slice any, setFunc func(*ConversionCreate, int)) *ConversionCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ConversionCreateBulk{err: fmt.Errorf("calling to ConversionClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ConversionCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ConversionCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Conversion. func (c *ConversionClient) Update() *ConversionUpdate { mutation := newConversionMutation(c.config, OpUpdate) @@ -510,6 +541,21 @@ func (c *CustomTypeClient) CreateBulk(builders ...*CustomTypeCreate) *CustomType return &CustomTypeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CustomTypeClient) MapCreateBulk(slice any, setFunc func(*CustomTypeCreate, int)) *CustomTypeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CustomTypeCreateBulk{err: fmt.Errorf("calling to CustomTypeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CustomTypeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CustomTypeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for CustomType. func (c *CustomTypeClient) Update() *CustomTypeUpdate { mutation := newCustomTypeMutation(c.config, OpUpdate) @@ -628,6 +674,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/migrate/entv1/conversion_create.go b/entc/integration/migrate/entv1/conversion_create.go index f809ba04b..e890723c8 100644 --- a/entc/integration/migrate/entv1/conversion_create.go +++ b/entc/integration/migrate/entv1/conversion_create.go @@ -250,11 +250,15 @@ func (cc *ConversionCreate) createSpec() (*Conversion, *sqlgraph.CreateSpec) { // ConversionCreateBulk is the builder for creating many Conversion entities in bulk. type ConversionCreateBulk struct { config + err error builders []*ConversionCreate } // Save creates the Conversion entities in the database. func (ccb *ConversionCreateBulk) Save(ctx context.Context) ([]*Conversion, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Conversion, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/migrate/entv1/customtype_create.go b/entc/integration/migrate/entv1/customtype_create.go index 5ba248bea..e2e119320 100644 --- a/entc/integration/migrate/entv1/customtype_create.go +++ b/entc/integration/migrate/entv1/customtype_create.go @@ -106,11 +106,15 @@ func (ctc *CustomTypeCreate) createSpec() (*CustomType, *sqlgraph.CreateSpec) { // CustomTypeCreateBulk is the builder for creating many CustomType entities in bulk. type CustomTypeCreateBulk struct { config + err error builders []*CustomTypeCreate } // Save creates the CustomType entities in the database. func (ctcb *CustomTypeCreateBulk) Save(ctx context.Context) ([]*CustomType, error) { + if ctcb.err != nil { + return nil, ctcb.err + } specs := make([]*sqlgraph.CreateSpec, len(ctcb.builders)) nodes := make([]*CustomType, len(ctcb.builders)) mutators := make([]Mutator, len(ctcb.builders)) diff --git a/entc/integration/migrate/entv1/user_create.go b/entc/integration/migrate/entv1/user_create.go index ca65cf25f..dd26a721a 100644 --- a/entc/integration/migrate/entv1/user_create.go +++ b/entc/integration/migrate/entv1/user_create.go @@ -469,11 +469,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/migrate/entv2/blog_create.go b/entc/integration/migrate/entv2/blog_create.go index 71421376a..2bbea9d91 100644 --- a/entc/integration/migrate/entv2/blog_create.go +++ b/entc/integration/migrate/entv2/blog_create.go @@ -150,11 +150,15 @@ func (bc *BlogCreate) createSpec() (*Blog, *sqlgraph.CreateSpec) { // BlogCreateBulk is the builder for creating many Blog entities in bulk. type BlogCreateBulk struct { config + err error builders []*BlogCreate } // Save creates the Blog entities in the database. func (bcb *BlogCreateBulk) Save(ctx context.Context) ([]*Blog, error) { + if bcb.err != nil { + return nil, bcb.err + } specs := make([]*sqlgraph.CreateSpec, len(bcb.builders)) nodes := make([]*Blog, len(bcb.builders)) mutators := make([]Mutator, len(bcb.builders)) diff --git a/entc/integration/migrate/entv2/car_create.go b/entc/integration/migrate/entv2/car_create.go index 37647652d..6a0f797a6 100644 --- a/entc/integration/migrate/entv2/car_create.go +++ b/entc/integration/migrate/entv2/car_create.go @@ -139,11 +139,15 @@ func (cc *CarCreate) createSpec() (*Car, *sqlgraph.CreateSpec) { // CarCreateBulk is the builder for creating many Car entities in bulk. type CarCreateBulk struct { config + err error builders []*CarCreate } // Save creates the Car entities in the database. func (ccb *CarCreateBulk) Save(ctx context.Context) ([]*Car, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Car, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/migrate/entv2/client.go b/entc/integration/migrate/entv2/client.go index 5ddab2882..c2a6fe5a6 100644 --- a/entc/integration/migrate/entv2/client.go +++ b/entc/integration/migrate/entv2/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/migrate/entv2/migrate" @@ -302,6 +303,21 @@ func (c *BlogClient) CreateBulk(builders ...*BlogCreate) *BlogCreateBulk { return &BlogCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *BlogClient) MapCreateBulk(slice any, setFunc func(*BlogCreate, int)) *BlogCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &BlogCreateBulk{err: fmt.Errorf("calling to BlogClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*BlogCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &BlogCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Blog. func (c *BlogClient) Update() *BlogUpdate { mutation := newBlogMutation(c.config, OpUpdate) @@ -436,6 +452,21 @@ func (c *CarClient) CreateBulk(builders ...*CarCreate) *CarCreateBulk { return &CarCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CarClient) MapCreateBulk(slice any, setFunc func(*CarCreate, int)) *CarCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CarCreateBulk{err: fmt.Errorf("calling to CarClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CarCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CarCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Car. func (c *CarClient) Update() *CarUpdate { mutation := newCarMutation(c.config, OpUpdate) @@ -570,6 +601,21 @@ func (c *ConversionClient) CreateBulk(builders ...*ConversionCreate) *Conversion return &ConversionCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ConversionClient) MapCreateBulk(slice any, setFunc func(*ConversionCreate, int)) *ConversionCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ConversionCreateBulk{err: fmt.Errorf("calling to ConversionClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ConversionCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ConversionCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Conversion. func (c *ConversionClient) Update() *ConversionUpdate { mutation := newConversionMutation(c.config, OpUpdate) @@ -688,6 +734,21 @@ func (c *CustomTypeClient) CreateBulk(builders ...*CustomTypeCreate) *CustomType return &CustomTypeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CustomTypeClient) MapCreateBulk(slice any, setFunc func(*CustomTypeCreate, int)) *CustomTypeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CustomTypeCreateBulk{err: fmt.Errorf("calling to CustomTypeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CustomTypeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CustomTypeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for CustomType. func (c *CustomTypeClient) Update() *CustomTypeUpdate { mutation := newCustomTypeMutation(c.config, OpUpdate) @@ -806,6 +867,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -924,6 +1000,21 @@ func (c *MediaClient) CreateBulk(builders ...*MediaCreate) *MediaCreateBulk { return &MediaCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *MediaClient) MapCreateBulk(slice any, setFunc func(*MediaCreate, int)) *MediaCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &MediaCreateBulk{err: fmt.Errorf("calling to MediaClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*MediaCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &MediaCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Media. func (c *MediaClient) Update() *MediaUpdate { mutation := newMediaMutation(c.config, OpUpdate) @@ -1042,6 +1133,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -1176,6 +1282,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) @@ -1342,6 +1463,21 @@ func (c *ZooClient) CreateBulk(builders ...*ZooCreate) *ZooCreateBulk { return &ZooCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *ZooClient) MapCreateBulk(slice any, setFunc func(*ZooCreate, int)) *ZooCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &ZooCreateBulk{err: fmt.Errorf("calling to ZooClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*ZooCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &ZooCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Zoo. func (c *ZooClient) Update() *ZooUpdate { mutation := newZooMutation(c.config, OpUpdate) diff --git a/entc/integration/migrate/entv2/conversion_create.go b/entc/integration/migrate/entv2/conversion_create.go index 9423c8131..a6159ac32 100644 --- a/entc/integration/migrate/entv2/conversion_create.go +++ b/entc/integration/migrate/entv2/conversion_create.go @@ -250,11 +250,15 @@ func (cc *ConversionCreate) createSpec() (*Conversion, *sqlgraph.CreateSpec) { // ConversionCreateBulk is the builder for creating many Conversion entities in bulk. type ConversionCreateBulk struct { config + err error builders []*ConversionCreate } // Save creates the Conversion entities in the database. func (ccb *ConversionCreateBulk) Save(ctx context.Context) ([]*Conversion, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Conversion, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/entc/integration/migrate/entv2/customtype_create.go b/entc/integration/migrate/entv2/customtype_create.go index 52ab19cbd..3865c481d 100644 --- a/entc/integration/migrate/entv2/customtype_create.go +++ b/entc/integration/migrate/entv2/customtype_create.go @@ -143,11 +143,15 @@ func (ctc *CustomTypeCreate) createSpec() (*CustomType, *sqlgraph.CreateSpec) { // CustomTypeCreateBulk is the builder for creating many CustomType entities in bulk. type CustomTypeCreateBulk struct { config + err error builders []*CustomTypeCreate } // Save creates the CustomType entities in the database. func (ctcb *CustomTypeCreateBulk) Save(ctx context.Context) ([]*CustomType, error) { + if ctcb.err != nil { + return nil, ctcb.err + } specs := make([]*sqlgraph.CreateSpec, len(ctcb.builders)) nodes := make([]*CustomType, len(ctcb.builders)) mutators := make([]Mutator, len(ctcb.builders)) diff --git a/entc/integration/migrate/entv2/group_create.go b/entc/integration/migrate/entv2/group_create.go index b89c7b9f2..91546698e 100644 --- a/entc/integration/migrate/entv2/group_create.go +++ b/entc/integration/migrate/entv2/group_create.go @@ -88,11 +88,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/entc/integration/migrate/entv2/media_create.go b/entc/integration/migrate/entv2/media_create.go index f7ff2ceae..ddeb356a8 100644 --- a/entc/integration/migrate/entv2/media_create.go +++ b/entc/integration/migrate/entv2/media_create.go @@ -142,11 +142,15 @@ func (mc *MediaCreate) createSpec() (*Media, *sqlgraph.CreateSpec) { // MediaCreateBulk is the builder for creating many Media entities in bulk. type MediaCreateBulk struct { config + err error builders []*MediaCreate } // Save creates the Media entities in the database. func (mcb *MediaCreateBulk) Save(ctx context.Context) ([]*Media, error) { + if mcb.err != nil { + return nil, mcb.err + } specs := make([]*sqlgraph.CreateSpec, len(mcb.builders)) nodes := make([]*Media, len(mcb.builders)) mutators := make([]Mutator, len(mcb.builders)) diff --git a/entc/integration/migrate/entv2/pet_create.go b/entc/integration/migrate/entv2/pet_create.go index 3ada89f12..951cee305 100644 --- a/entc/integration/migrate/entv2/pet_create.go +++ b/entc/integration/migrate/entv2/pet_create.go @@ -143,11 +143,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/migrate/entv2/user_create.go b/entc/integration/migrate/entv2/user_create.go index 12a43a0e7..2392d8a31 100644 --- a/entc/integration/migrate/entv2/user_create.go +++ b/entc/integration/migrate/entv2/user_create.go @@ -634,11 +634,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/migrate/entv2/zoo_create.go b/entc/integration/migrate/entv2/zoo_create.go index eee3a0372..c3fd0cc49 100644 --- a/entc/integration/migrate/entv2/zoo_create.go +++ b/entc/integration/migrate/entv2/zoo_create.go @@ -100,11 +100,15 @@ func (zc *ZooCreate) createSpec() (*Zoo, *sqlgraph.CreateSpec) { // ZooCreateBulk is the builder for creating many Zoo entities in bulk. type ZooCreateBulk struct { config + err error builders []*ZooCreate } // Save creates the Zoo entities in the database. func (zcb *ZooCreateBulk) Save(ctx context.Context) ([]*Zoo, error) { + if zcb.err != nil { + return nil, zcb.err + } specs := make([]*sqlgraph.CreateSpec, len(zcb.builders)) nodes := make([]*Zoo, len(zcb.builders)) mutators := make([]Mutator, len(zcb.builders)) diff --git a/entc/integration/migrate/versioned/client.go b/entc/integration/migrate/versioned/client.go index ec3555336..45893c3e1 100644 --- a/entc/integration/migrate/versioned/client.go +++ b/entc/integration/migrate/versioned/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/migrate/versioned/migrate" @@ -237,6 +238,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -355,6 +371,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/migrate/versioned/group_create.go b/entc/integration/migrate/versioned/group_create.go index a01cecbba..8e8f81109 100644 --- a/entc/integration/migrate/versioned/group_create.go +++ b/entc/integration/migrate/versioned/group_create.go @@ -102,11 +102,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/entc/integration/migrate/versioned/user_create.go b/entc/integration/migrate/versioned/user_create.go index 67128b56a..0c0253178 100644 --- a/entc/integration/migrate/versioned/user_create.go +++ b/entc/integration/migrate/versioned/user_create.go @@ -138,11 +138,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/multischema/ent/client.go b/entc/integration/multischema/ent/client.go index c34258100..b1425d269 100644 --- a/entc/integration/multischema/ent/client.go +++ b/entc/integration/multischema/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/multischema/ent/migrate" @@ -262,6 +263,21 @@ func (c *FriendshipClient) CreateBulk(builders ...*FriendshipCreate) *Friendship return &FriendshipCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FriendshipClient) MapCreateBulk(slice any, setFunc func(*FriendshipCreate, int)) *FriendshipCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FriendshipCreateBulk{err: fmt.Errorf("calling to FriendshipClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FriendshipCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FriendshipCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Friendship. func (c *FriendshipClient) Update() *FriendshipUpdate { mutation := newFriendshipMutation(c.config, OpUpdate) @@ -418,6 +434,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -555,6 +586,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -692,6 +738,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/multischema/ent/friendship_create.go b/entc/integration/multischema/ent/friendship_create.go index 408bdb6a1..8ced6eb09 100644 --- a/entc/integration/multischema/ent/friendship_create.go +++ b/entc/integration/multischema/ent/friendship_create.go @@ -217,11 +217,15 @@ func (fc *FriendshipCreate) createSpec() (*Friendship, *sqlgraph.CreateSpec) { // FriendshipCreateBulk is the builder for creating many Friendship entities in bulk. type FriendshipCreateBulk struct { config + err error builders []*FriendshipCreate } // Save creates the Friendship entities in the database. func (fcb *FriendshipCreateBulk) Save(ctx context.Context) ([]*Friendship, error) { + if fcb.err != nil { + return nil, fcb.err + } specs := make([]*sqlgraph.CreateSpec, len(fcb.builders)) nodes := make([]*Friendship, len(fcb.builders)) mutators := make([]Mutator, len(fcb.builders)) diff --git a/entc/integration/multischema/ent/group_create.go b/entc/integration/multischema/ent/group_create.go index 6404b4db6..bdba1aba0 100644 --- a/entc/integration/multischema/ent/group_create.go +++ b/entc/integration/multischema/ent/group_create.go @@ -153,11 +153,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/entc/integration/multischema/ent/pet_create.go b/entc/integration/multischema/ent/pet_create.go index dfa8ecefa..b2625dd84 100644 --- a/entc/integration/multischema/ent/pet_create.go +++ b/entc/integration/multischema/ent/pet_create.go @@ -158,11 +158,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/multischema/ent/user_create.go b/entc/integration/multischema/ent/user_create.go index 21871366a..b3699c71a 100644 --- a/entc/integration/multischema/ent/user_create.go +++ b/entc/integration/multischema/ent/user_create.go @@ -255,11 +255,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/privacy/ent/client.go b/entc/integration/privacy/ent/client.go index fa3b2ea01..f9cd78f47 100644 --- a/entc/integration/privacy/ent/client.go +++ b/entc/integration/privacy/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/privacy/ent/migrate" @@ -258,6 +259,21 @@ func (c *TaskClient) CreateBulk(builders ...*TaskCreate) *TaskCreateBulk { return &TaskCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TaskClient) MapCreateBulk(slice any, setFunc func(*TaskCreate, int)) *TaskCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TaskCreateBulk{err: fmt.Errorf("calling to TaskClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TaskCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TaskCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Task. func (c *TaskClient) Update() *TaskUpdate { mutation := newTaskMutation(c.config, OpUpdate) @@ -409,6 +425,21 @@ func (c *TeamClient) CreateBulk(builders ...*TeamCreate) *TeamCreateBulk { return &TeamCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TeamClient) MapCreateBulk(slice any, setFunc func(*TeamCreate, int)) *TeamCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TeamCreateBulk{err: fmt.Errorf("calling to TeamClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TeamCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TeamCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Team. func (c *TeamClient) Update() *TeamUpdate { mutation := newTeamMutation(c.config, OpUpdate) @@ -560,6 +591,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/privacy/ent/task_create.go b/entc/integration/privacy/ent/task_create.go index 978ba5072..ccd4a9339 100644 --- a/entc/integration/privacy/ent/task_create.go +++ b/entc/integration/privacy/ent/task_create.go @@ -251,11 +251,15 @@ func (tc *TaskCreate) createSpec() (*Task, *sqlgraph.CreateSpec) { // TaskCreateBulk is the builder for creating many Task entities in bulk. type TaskCreateBulk struct { config + err error builders []*TaskCreate } // Save creates the Task entities in the database. func (tcb *TaskCreateBulk) Save(ctx context.Context) ([]*Task, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Task, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) diff --git a/entc/integration/privacy/ent/team_create.go b/entc/integration/privacy/ent/team_create.go index 7331edd4a..a1598b2ad 100644 --- a/entc/integration/privacy/ent/team_create.go +++ b/entc/integration/privacy/ent/team_create.go @@ -171,11 +171,15 @@ func (tc *TeamCreate) createSpec() (*Team, *sqlgraph.CreateSpec) { // TeamCreateBulk is the builder for creating many Team entities in bulk. type TeamCreateBulk struct { config + err error builders []*TeamCreate } // Save creates the Team entities in the database. func (tcb *TeamCreateBulk) Save(ctx context.Context) ([]*Team, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Team, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) diff --git a/entc/integration/privacy/ent/user_create.go b/entc/integration/privacy/ent/user_create.go index 63a43f330..62e540b12 100644 --- a/entc/integration/privacy/ent/user_create.go +++ b/entc/integration/privacy/ent/user_create.go @@ -189,11 +189,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/entc/integration/template/ent/client.go b/entc/integration/template/ent/client.go index 1035080a9..3afc7863b 100644 --- a/entc/integration/template/ent/client.go +++ b/entc/integration/template/ent/client.go @@ -12,6 +12,7 @@ import ( "fmt" "log" "net/http" + "reflect" "entgo.io/ent" "entgo.io/ent/entc/integration/template/ent/migrate" @@ -260,6 +261,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -379,6 +395,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -514,6 +545,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/entc/integration/template/ent/group_create.go b/entc/integration/template/ent/group_create.go index 6051fa9bf..1bebe6733 100644 --- a/entc/integration/template/ent/group_create.go +++ b/entc/integration/template/ent/group_create.go @@ -102,11 +102,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/entc/integration/template/ent/pet_create.go b/entc/integration/template/ent/pet_create.go index 51510d38d..c8045dd99 100644 --- a/entc/integration/template/ent/pet_create.go +++ b/entc/integration/template/ent/pet_create.go @@ -158,11 +158,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/entc/integration/template/ent/user_create.go b/entc/integration/template/ent/user_create.go index de66cc507..b59ebd7a2 100644 --- a/entc/integration/template/ent/user_create.go +++ b/entc/integration/template/ent/user_create.go @@ -165,11 +165,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/edgeindex/ent/city_create.go b/examples/edgeindex/ent/city_create.go index f98528498..361440270 100644 --- a/examples/edgeindex/ent/city_create.go +++ b/examples/edgeindex/ent/city_create.go @@ -134,11 +134,15 @@ func (cc *CityCreate) createSpec() (*City, *sqlgraph.CreateSpec) { // CityCreateBulk is the builder for creating many City entities in bulk. type CityCreateBulk struct { config + err error builders []*CityCreate } // Save creates the City entities in the database. func (ccb *CityCreateBulk) Save(ctx context.Context) ([]*City, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*City, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/examples/edgeindex/ent/client.go b/examples/edgeindex/ent/client.go index d33919402..80a375dc1 100644 --- a/examples/edgeindex/ent/client.go +++ b/examples/edgeindex/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/edgeindex/ent/migrate" @@ -238,6 +239,21 @@ func (c *CityClient) CreateBulk(builders ...*CityCreate) *CityCreateBulk { return &CityCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CityClient) MapCreateBulk(slice any, setFunc func(*CityCreate, int)) *CityCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CityCreateBulk{err: fmt.Errorf("calling to CityClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CityCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CityCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for City. func (c *CityClient) Update() *CityUpdate { mutation := newCityMutation(c.config, OpUpdate) @@ -372,6 +388,21 @@ func (c *StreetClient) CreateBulk(builders ...*StreetCreate) *StreetCreateBulk { return &StreetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *StreetClient) MapCreateBulk(slice any, setFunc func(*StreetCreate, int)) *StreetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &StreetCreateBulk{err: fmt.Errorf("calling to StreetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*StreetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &StreetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Street. func (c *StreetClient) Update() *StreetUpdate { mutation := newStreetMutation(c.config, OpUpdate) diff --git a/examples/edgeindex/ent/street_create.go b/examples/edgeindex/ent/street_create.go index bafd59f18..3c5b12c58 100644 --- a/examples/edgeindex/ent/street_create.go +++ b/examples/edgeindex/ent/street_create.go @@ -139,11 +139,15 @@ func (sc *StreetCreate) createSpec() (*Street, *sqlgraph.CreateSpec) { // StreetCreateBulk is the builder for creating many Street entities in bulk. type StreetCreateBulk struct { config + err error builders []*StreetCreate } // Save creates the Street entities in the database. func (scb *StreetCreateBulk) Save(ctx context.Context) ([]*Street, error) { + if scb.err != nil { + return nil, scb.err + } specs := make([]*sqlgraph.CreateSpec, len(scb.builders)) nodes := make([]*Street, len(scb.builders)) mutators := make([]Mutator, len(scb.builders)) diff --git a/examples/encryptfield/ent/client.go b/examples/encryptfield/ent/client.go index d0a587eea..380616558 100644 --- a/examples/encryptfield/ent/client.go +++ b/examples/encryptfield/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/encryptfield/ent/migrate" @@ -236,6 +237,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/encryptfield/ent/user_create.go b/examples/encryptfield/ent/user_create.go index a5f4d173a..5c5b9c2fe 100644 --- a/examples/encryptfield/ent/user_create.go +++ b/examples/encryptfield/ent/user_create.go @@ -120,11 +120,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/entcpkg/ent/client.go b/examples/entcpkg/ent/client.go index 3877bdf77..1a7b4d08a 100644 --- a/examples/entcpkg/ent/client.go +++ b/examples/entcpkg/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/entcpkg/ent/migrate" @@ -246,6 +247,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/entcpkg/ent/user_create.go b/examples/entcpkg/ent/user_create.go index 4c269bb55..02ac6b777 100644 --- a/examples/entcpkg/ent/user_create.go +++ b/examples/entcpkg/ent/user_create.go @@ -124,11 +124,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/fs/ent/client.go b/examples/fs/ent/client.go index f014f313d..01aef44c8 100644 --- a/examples/fs/ent/client.go +++ b/examples/fs/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/fs/ent/migrate" @@ -228,6 +229,21 @@ func (c *FileClient) CreateBulk(builders ...*FileCreate) *FileCreateBulk { return &FileCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *FileClient) MapCreateBulk(slice any, setFunc func(*FileCreate, int)) *FileCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &FileCreateBulk{err: fmt.Errorf("calling to FileClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*FileCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &FileCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for File. func (c *FileClient) Update() *FileUpdate { mutation := newFileMutation(c.config, OpUpdate) diff --git a/examples/fs/ent/file_create.go b/examples/fs/ent/file_create.go index bd029a8c9..027d68788 100644 --- a/examples/fs/ent/file_create.go +++ b/examples/fs/ent/file_create.go @@ -199,11 +199,15 @@ func (fc *FileCreate) createSpec() (*File, *sqlgraph.CreateSpec) { // FileCreateBulk is the builder for creating many File entities in bulk. type FileCreateBulk struct { config + err error builders []*FileCreate } // Save creates the File entities in the database. func (fcb *FileCreateBulk) Save(ctx context.Context) ([]*File, error) { + if fcb.err != nil { + return nil, fcb.err + } specs := make([]*sqlgraph.CreateSpec, len(fcb.builders)) nodes := make([]*File, len(fcb.builders)) mutators := make([]Mutator, len(fcb.builders)) diff --git a/examples/jsonencode/ent/card_create.go b/examples/jsonencode/ent/card_create.go index 6dca1e2d0..5d155a2fc 100644 --- a/examples/jsonencode/ent/card_create.go +++ b/examples/jsonencode/ent/card_create.go @@ -102,11 +102,15 @@ func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate } // Save creates the Card entities in the database. func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Card, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/examples/jsonencode/ent/client.go b/examples/jsonencode/ent/client.go index cb742a02f..25afd222b 100644 --- a/examples/jsonencode/ent/client.go +++ b/examples/jsonencode/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/jsonencode/ent/migrate" @@ -248,6 +249,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -366,6 +382,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -500,6 +531,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/jsonencode/ent/pet_create.go b/examples/jsonencode/ent/pet_create.go index 0bd8f4325..20caf129c 100644 --- a/examples/jsonencode/ent/pet_create.go +++ b/examples/jsonencode/ent/pet_create.go @@ -150,11 +150,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/examples/jsonencode/ent/user_create.go b/examples/jsonencode/ent/user_create.go index 9d45e390c..d520ccc30 100644 --- a/examples/jsonencode/ent/user_create.go +++ b/examples/jsonencode/ent/user_create.go @@ -147,11 +147,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/m2m2types/ent/client.go b/examples/m2m2types/ent/client.go index 59f718417..4e1ad6b4c 100644 --- a/examples/m2m2types/ent/client.go +++ b/examples/m2m2types/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/m2m2types/ent/migrate" @@ -238,6 +239,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -372,6 +388,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/m2m2types/ent/group_create.go b/examples/m2m2types/ent/group_create.go index 2b2c1454a..e4100313b 100644 --- a/examples/m2m2types/ent/group_create.go +++ b/examples/m2m2types/ent/group_create.go @@ -134,11 +134,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/examples/m2m2types/ent/user_create.go b/examples/m2m2types/ent/user_create.go index 382e35241..96d471222 100644 --- a/examples/m2m2types/ent/user_create.go +++ b/examples/m2m2types/ent/user_create.go @@ -147,11 +147,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/m2mbidi/ent/client.go b/examples/m2mbidi/ent/client.go index c7afccddd..ae585ae2e 100644 --- a/examples/m2mbidi/ent/client.go +++ b/examples/m2mbidi/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/m2mbidi/ent/migrate" @@ -228,6 +229,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/m2mbidi/ent/user_create.go b/examples/m2mbidi/ent/user_create.go index 1f4bf0fbd..f8cb2ec64 100644 --- a/examples/m2mbidi/ent/user_create.go +++ b/examples/m2mbidi/ent/user_create.go @@ -146,11 +146,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/m2mrecur/ent/client.go b/examples/m2mrecur/ent/client.go index dc2aebdca..506d7a956 100644 --- a/examples/m2mrecur/ent/client.go +++ b/examples/m2mrecur/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/m2mrecur/ent/migrate" @@ -228,6 +229,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/m2mrecur/ent/user_create.go b/examples/m2mrecur/ent/user_create.go index 9fdcd9131..bfa8245ff 100644 --- a/examples/m2mrecur/ent/user_create.go +++ b/examples/m2mrecur/ent/user_create.go @@ -177,11 +177,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/migration/ent/card_create.go b/examples/migration/ent/card_create.go index 6c0919698..f02aa0345 100644 --- a/examples/migration/ent/card_create.go +++ b/examples/migration/ent/card_create.go @@ -141,11 +141,15 @@ func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate } // Save creates the Card entities in the database. func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Card, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/examples/migration/ent/client.go b/examples/migration/ent/client.go index 8907b14b3..cf2463c37 100644 --- a/examples/migration/ent/client.go +++ b/examples/migration/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/migration/ent/migrate" @@ -249,6 +250,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -383,6 +399,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -533,6 +564,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/migration/ent/pet_create.go b/examples/migration/ent/pet_create.go index 85fc2713c..2ee8e613a 100644 --- a/examples/migration/ent/pet_create.go +++ b/examples/migration/ent/pet_create.go @@ -203,11 +203,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/examples/migration/ent/user_create.go b/examples/migration/ent/user_create.go index c0f4eb048..b4c3ee457 100644 --- a/examples/migration/ent/user_create.go +++ b/examples/migration/ent/user_create.go @@ -157,11 +157,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/o2m2types/ent/client.go b/examples/o2m2types/ent/client.go index eac0b2c57..bd00c28cd 100644 --- a/examples/o2m2types/ent/client.go +++ b/examples/o2m2types/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/o2m2types/ent/migrate" @@ -238,6 +239,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -372,6 +388,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/o2m2types/ent/pet_create.go b/examples/o2m2types/ent/pet_create.go index db77aa2b3..77b80bc29 100644 --- a/examples/o2m2types/ent/pet_create.go +++ b/examples/o2m2types/ent/pet_create.go @@ -139,11 +139,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/examples/o2m2types/ent/user_create.go b/examples/o2m2types/ent/user_create.go index 62f217299..3f30742b4 100644 --- a/examples/o2m2types/ent/user_create.go +++ b/examples/o2m2types/ent/user_create.go @@ -147,11 +147,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/o2mrecur/ent/client.go b/examples/o2mrecur/ent/client.go index 7d9de8f8f..9d2a9840d 100644 --- a/examples/o2mrecur/ent/client.go +++ b/examples/o2mrecur/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/o2mrecur/ent/migrate" @@ -228,6 +229,21 @@ func (c *NodeClient) CreateBulk(builders ...*NodeCreate) *NodeCreateBulk { return &NodeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *NodeClient) MapCreateBulk(slice any, setFunc func(*NodeCreate, int)) *NodeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &NodeCreateBulk{err: fmt.Errorf("calling to NodeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*NodeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &NodeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Node. func (c *NodeClient) Update() *NodeUpdate { mutation := newNodeMutation(c.config, OpUpdate) diff --git a/examples/o2mrecur/ent/node_create.go b/examples/o2mrecur/ent/node_create.go index 40da02320..ad8d2e2fc 100644 --- a/examples/o2mrecur/ent/node_create.go +++ b/examples/o2mrecur/ent/node_create.go @@ -169,11 +169,15 @@ func (nc *NodeCreate) createSpec() (*Node, *sqlgraph.CreateSpec) { // NodeCreateBulk is the builder for creating many Node entities in bulk. type NodeCreateBulk struct { config + err error builders []*NodeCreate } // Save creates the Node entities in the database. func (ncb *NodeCreateBulk) Save(ctx context.Context) ([]*Node, error) { + if ncb.err != nil { + return nil, ncb.err + } specs := make([]*sqlgraph.CreateSpec, len(ncb.builders)) nodes := make([]*Node, len(ncb.builders)) mutators := make([]Mutator, len(ncb.builders)) diff --git a/examples/o2o2types/ent/card_create.go b/examples/o2o2types/ent/card_create.go index 01ac3a6f2..34bd2db1e 100644 --- a/examples/o2o2types/ent/card_create.go +++ b/examples/o2o2types/ent/card_create.go @@ -148,11 +148,15 @@ func (cc *CardCreate) createSpec() (*Card, *sqlgraph.CreateSpec) { // CardCreateBulk is the builder for creating many Card entities in bulk. type CardCreateBulk struct { config + err error builders []*CardCreate } // Save creates the Card entities in the database. func (ccb *CardCreateBulk) Save(ctx context.Context) ([]*Card, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Card, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/examples/o2o2types/ent/client.go b/examples/o2o2types/ent/client.go index 02033fa78..2b9271b72 100644 --- a/examples/o2o2types/ent/client.go +++ b/examples/o2o2types/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/o2o2types/ent/migrate" @@ -238,6 +239,21 @@ func (c *CardClient) CreateBulk(builders ...*CardCreate) *CardCreateBulk { return &CardCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CardClient) MapCreateBulk(slice any, setFunc func(*CardCreate, int)) *CardCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CardCreateBulk{err: fmt.Errorf("calling to CardClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CardCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CardCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Card. func (c *CardClient) Update() *CardUpdate { mutation := newCardMutation(c.config, OpUpdate) @@ -372,6 +388,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/o2o2types/ent/user_create.go b/examples/o2o2types/ent/user_create.go index 4a0a65b18..eeed8f22a 100644 --- a/examples/o2o2types/ent/user_create.go +++ b/examples/o2o2types/ent/user_create.go @@ -151,11 +151,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/o2obidi/ent/client.go b/examples/o2obidi/ent/client.go index d7ad88a4b..70b118968 100644 --- a/examples/o2obidi/ent/client.go +++ b/examples/o2obidi/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/o2obidi/ent/migrate" @@ -228,6 +229,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/o2obidi/ent/user_create.go b/examples/o2obidi/ent/user_create.go index 5dd0febce..b170da575 100644 --- a/examples/o2obidi/ent/user_create.go +++ b/examples/o2obidi/ent/user_create.go @@ -151,11 +151,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/o2orecur/ent/client.go b/examples/o2orecur/ent/client.go index dcc53a74a..6c591715a 100644 --- a/examples/o2orecur/ent/client.go +++ b/examples/o2orecur/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/o2orecur/ent/migrate" @@ -228,6 +229,21 @@ func (c *NodeClient) CreateBulk(builders ...*NodeCreate) *NodeCreateBulk { return &NodeCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *NodeClient) MapCreateBulk(slice any, setFunc func(*NodeCreate, int)) *NodeCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &NodeCreateBulk{err: fmt.Errorf("calling to NodeClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*NodeCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &NodeCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Node. func (c *NodeClient) Update() *NodeUpdate { mutation := newNodeMutation(c.config, OpUpdate) diff --git a/examples/o2orecur/ent/node_create.go b/examples/o2orecur/ent/node_create.go index 97a39bcff..98a0850ff 100644 --- a/examples/o2orecur/ent/node_create.go +++ b/examples/o2orecur/ent/node_create.go @@ -173,11 +173,15 @@ func (nc *NodeCreate) createSpec() (*Node, *sqlgraph.CreateSpec) { // NodeCreateBulk is the builder for creating many Node entities in bulk. type NodeCreateBulk struct { config + err error builders []*NodeCreate } // Save creates the Node entities in the database. func (ncb *NodeCreateBulk) Save(ctx context.Context) ([]*Node, error) { + if ncb.err != nil { + return nil, ncb.err + } specs := make([]*sqlgraph.CreateSpec, len(ncb.builders)) nodes := make([]*Node, len(ncb.builders)) mutators := make([]Mutator, len(ncb.builders)) diff --git a/examples/privacyadmin/ent/client.go b/examples/privacyadmin/ent/client.go index ff3b038fe..8b3e96021 100644 --- a/examples/privacyadmin/ent/client.go +++ b/examples/privacyadmin/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/privacyadmin/ent/migrate" @@ -227,6 +228,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/privacyadmin/ent/user_create.go b/examples/privacyadmin/ent/user_create.go index e917a6e07..a51d84548 100644 --- a/examples/privacyadmin/ent/user_create.go +++ b/examples/privacyadmin/ent/user_create.go @@ -122,11 +122,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/privacytenant/ent/client.go b/examples/privacytenant/ent/client.go index 29aacb6c2..f7219b23e 100644 --- a/examples/privacytenant/ent/client.go +++ b/examples/privacytenant/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/privacytenant/ent/migrate" @@ -248,6 +249,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -399,6 +415,21 @@ func (c *TenantClient) CreateBulk(builders ...*TenantCreate) *TenantCreateBulk { return &TenantCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *TenantClient) MapCreateBulk(slice any, setFunc func(*TenantCreate, int)) *TenantCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &TenantCreateBulk{err: fmt.Errorf("calling to TenantClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*TenantCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &TenantCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Tenant. func (c *TenantClient) Update() *TenantUpdate { mutation := newTenantMutation(c.config, OpUpdate) @@ -518,6 +549,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/privacytenant/ent/group_create.go b/examples/privacytenant/ent/group_create.go index 7dcfb936a..26d8e8e02 100644 --- a/examples/privacytenant/ent/group_create.go +++ b/examples/privacytenant/ent/group_create.go @@ -189,11 +189,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/examples/privacytenant/ent/tenant_create.go b/examples/privacytenant/ent/tenant_create.go index 8a57ce2d6..81f9ff8fe 100644 --- a/examples/privacytenant/ent/tenant_create.go +++ b/examples/privacytenant/ent/tenant_create.go @@ -107,11 +107,15 @@ func (tc *TenantCreate) createSpec() (*Tenant, *sqlgraph.CreateSpec) { // TenantCreateBulk is the builder for creating many Tenant entities in bulk. type TenantCreateBulk struct { config + err error builders []*TenantCreate } // Save creates the Tenant entities in the database. func (tcb *TenantCreateBulk) Save(ctx context.Context) ([]*Tenant, error) { + if tcb.err != nil { + return nil, tcb.err + } specs := make([]*sqlgraph.CreateSpec, len(tcb.builders)) nodes := make([]*Tenant, len(tcb.builders)) mutators := make([]Mutator, len(tcb.builders)) diff --git a/examples/privacytenant/ent/user_create.go b/examples/privacytenant/ent/user_create.go index 0a13b3567..024e5177d 100644 --- a/examples/privacytenant/ent/user_create.go +++ b/examples/privacytenant/ent/user_create.go @@ -199,11 +199,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/start/ent/car_create.go b/examples/start/ent/car_create.go index 1d723f0cc..164a487df 100644 --- a/examples/start/ent/car_create.go +++ b/examples/start/ent/car_create.go @@ -153,11 +153,15 @@ func (cc *CarCreate) createSpec() (*Car, *sqlgraph.CreateSpec) { // CarCreateBulk is the builder for creating many Car entities in bulk. type CarCreateBulk struct { config + err error builders []*CarCreate } // Save creates the Car entities in the database. func (ccb *CarCreateBulk) Save(ctx context.Context) ([]*Car, error) { + if ccb.err != nil { + return nil, ccb.err + } specs := make([]*sqlgraph.CreateSpec, len(ccb.builders)) nodes := make([]*Car, len(ccb.builders)) mutators := make([]Mutator, len(ccb.builders)) diff --git a/examples/start/ent/client.go b/examples/start/ent/client.go index 2906e6dc9..682451a42 100644 --- a/examples/start/ent/client.go +++ b/examples/start/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/start/ent/migrate" @@ -248,6 +249,21 @@ func (c *CarClient) CreateBulk(builders ...*CarCreate) *CarCreateBulk { return &CarCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *CarClient) MapCreateBulk(slice any, setFunc func(*CarCreate, int)) *CarCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &CarCreateBulk{err: fmt.Errorf("calling to CarClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*CarCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &CarCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Car. func (c *CarClient) Update() *CarUpdate { mutation := newCarMutation(c.config, OpUpdate) @@ -382,6 +398,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -516,6 +547,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/start/ent/group_create.go b/examples/start/ent/group_create.go index b4fc1b05c..680cacb19 100644 --- a/examples/start/ent/group_create.go +++ b/examples/start/ent/group_create.go @@ -139,11 +139,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/examples/start/ent/user_create.go b/examples/start/ent/user_create.go index f1110d609..081a1d910 100644 --- a/examples/start/ent/user_create.go +++ b/examples/start/ent/user_create.go @@ -201,11 +201,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/traversal/ent/client.go b/examples/traversal/ent/client.go index d4c453cf5..c652dfc96 100644 --- a/examples/traversal/ent/client.go +++ b/examples/traversal/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/traversal/ent/migrate" @@ -248,6 +249,21 @@ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk { return &GroupCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &GroupCreateBulk{err: fmt.Errorf("calling to GroupClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*GroupCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &GroupCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Group. func (c *GroupClient) Update() *GroupUpdate { mutation := newGroupMutation(c.config, OpUpdate) @@ -398,6 +414,21 @@ func (c *PetClient) CreateBulk(builders ...*PetCreate) *PetCreateBulk { return &PetCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *PetClient) MapCreateBulk(slice any, setFunc func(*PetCreate, int)) *PetCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &PetCreateBulk{err: fmt.Errorf("calling to PetClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*PetCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &PetCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for Pet. func (c *PetClient) Update() *PetUpdate { mutation := newPetMutation(c.config, OpUpdate) @@ -548,6 +579,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/traversal/ent/group_create.go b/examples/traversal/ent/group_create.go index c4bc86eff..df73310ab 100644 --- a/examples/traversal/ent/group_create.go +++ b/examples/traversal/ent/group_create.go @@ -170,11 +170,15 @@ func (gc *GroupCreate) createSpec() (*Group, *sqlgraph.CreateSpec) { // GroupCreateBulk is the builder for creating many Group entities in bulk. type GroupCreateBulk struct { config + err error builders []*GroupCreate } // Save creates the Group entities in the database. func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error) { + if gcb.err != nil { + return nil, gcb.err + } specs := make([]*sqlgraph.CreateSpec, len(gcb.builders)) nodes := make([]*Group, len(gcb.builders)) mutators := make([]Mutator, len(gcb.builders)) diff --git a/examples/traversal/ent/pet_create.go b/examples/traversal/ent/pet_create.go index 9f7789b79..0a2231bfd 100644 --- a/examples/traversal/ent/pet_create.go +++ b/examples/traversal/ent/pet_create.go @@ -170,11 +170,15 @@ func (pc *PetCreate) createSpec() (*Pet, *sqlgraph.CreateSpec) { // PetCreateBulk is the builder for creating many Pet entities in bulk. type PetCreateBulk struct { config + err error builders []*PetCreate } // Save creates the Pet entities in the database. func (pcb *PetCreateBulk) Save(ctx context.Context) ([]*Pet, error) { + if pcb.err != nil { + return nil, pcb.err + } specs := make([]*sqlgraph.CreateSpec, len(pcb.builders)) nodes := make([]*Pet, len(pcb.builders)) mutators := make([]Mutator, len(pcb.builders)) diff --git a/examples/traversal/ent/user_create.go b/examples/traversal/ent/user_create.go index 2bc9f9100..36405e31e 100644 --- a/examples/traversal/ent/user_create.go +++ b/examples/traversal/ent/user_create.go @@ -241,11 +241,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders)) diff --git a/examples/version/ent/client.go b/examples/version/ent/client.go index a02451c6d..50ad92d49 100644 --- a/examples/version/ent/client.go +++ b/examples/version/ent/client.go @@ -11,6 +11,7 @@ import ( "errors" "fmt" "log" + "reflect" "entgo.io/ent" "entgo.io/ent/examples/version/ent/migrate" @@ -227,6 +228,21 @@ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk { return &UserCreateBulk{config: c.config, builders: builders} } +// MapCreateBulk creates a bulk creation builder from the given slice. For each item in the slice, the function creates +// a builder and applies setFunc on it. +func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk { + rv := reflect.ValueOf(slice) + if rv.Kind() != reflect.Slice { + return &UserCreateBulk{err: fmt.Errorf("calling to UserClient.MapCreateBulk with wrong type %T, need slice", slice)} + } + builders := make([]*UserCreate, rv.Len()) + for i := 0; i < rv.Len(); i++ { + builders[i] = c.Create() + setFunc(builders[i], i) + } + return &UserCreateBulk{config: c.config, builders: builders} +} + // Update returns an update builder for User. func (c *UserClient) Update() *UserUpdate { mutation := newUserMutation(c.config, OpUpdate) diff --git a/examples/version/ent/user_create.go b/examples/version/ent/user_create.go index 8664f1a55..88155d626 100644 --- a/examples/version/ent/user_create.go +++ b/examples/version/ent/user_create.go @@ -137,11 +137,15 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) { // UserCreateBulk is the builder for creating many User entities in bulk. type UserCreateBulk struct { config + err error builders []*UserCreate } // Save creates the User entities in the database. func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error) { + if ucb.err != nil { + return nil, ucb.err + } specs := make([]*sqlgraph.CreateSpec, len(ucb.builders)) nodes := make([]*User, len(ucb.builders)) mutators := make([]Mutator, len(ucb.builders))