gamerole_create.go

// Code generated by ent, DO NOT EDIT.

package entity

import (
	"context"
	"errors"
	"fmt"
	"time"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/schema/field"
	"github.com/lostsnow/keqing/pkg/entity/gamerole"
)

// GameRoleCreate is the builder for creating a GameRole entity.
type GameRoleCreate struct {
	config
	mutation *GameRoleMutation
	hooks    []Hook
	conflict []sql.ConflictOption
}

// SetUserID sets the "user_id" field.
func (grc *GameRoleCreate) SetUserID(i int64) *GameRoleCreate {
	grc.mutation.SetUserID(i)
	return grc
}

// SetAccountID sets the "account_id" field.
func (grc *GameRoleCreate) SetAccountID(s string) *GameRoleCreate {
	grc.mutation.SetAccountID(s)
	return grc
}

// SetRoleID sets the "role_id" field.
func (grc *GameRoleCreate) SetRoleID(s string) *GameRoleCreate {
	grc.mutation.SetRoleID(s)
	return grc
}

// SetLevel sets the "level" field.
func (grc *GameRoleCreate) SetLevel(i int) *GameRoleCreate {
	grc.mutation.SetLevel(i)
	return grc
}

// SetNillableLevel sets the "level" field if the given value is not nil.
func (grc *GameRoleCreate) SetNillableLevel(i *int) *GameRoleCreate {
	if i != nil {
		grc.SetLevel(*i)
	}
	return grc
}

// SetRegion sets the "region" field.
func (grc *GameRoleCreate) SetRegion(s string) *GameRoleCreate {
	grc.mutation.SetRegion(s)
	return grc
}

// SetNillableRegion sets the "region" field if the given value is not nil.
func (grc *GameRoleCreate) SetNillableRegion(s *string) *GameRoleCreate {
	if s != nil {
		grc.SetRegion(*s)
	}
	return grc
}

// SetRegionName sets the "region_name" field.
func (grc *GameRoleCreate) SetRegionName(s string) *GameRoleCreate {
	grc.mutation.SetRegionName(s)
	return grc
}

// SetNillableRegionName sets the "region_name" field if the given value is not nil.
func (grc *GameRoleCreate) SetNillableRegionName(s *string) *GameRoleCreate {
	if s != nil {
		grc.SetRegionName(*s)
	}
	return grc
}

// SetNickName sets the "nick_name" field.
func (grc *GameRoleCreate) SetNickName(s string) *GameRoleCreate {
	grc.mutation.SetNickName(s)
	return grc
}

// SetNillableNickName sets the "nick_name" field if the given value is not nil.
func (grc *GameRoleCreate) SetNillableNickName(s *string) *GameRoleCreate {
	if s != nil {
		grc.SetNickName(*s)
	}
	return grc
}

// SetCreateAt sets the "create_at" field.
func (grc *GameRoleCreate) SetCreateAt(t time.Time) *GameRoleCreate {
	grc.mutation.SetCreateAt(t)
	return grc
}

// SetNillableCreateAt sets the "create_at" field if the given value is not nil.
func (grc *GameRoleCreate) SetNillableCreateAt(t *time.Time) *GameRoleCreate {
	if t != nil {
		grc.SetCreateAt(*t)
	}
	return grc
}

// SetUpdateAt sets the "update_at" field.
func (grc *GameRoleCreate) SetUpdateAt(t time.Time) *GameRoleCreate {
	grc.mutation.SetUpdateAt(t)
	return grc
}

// SetNillableUpdateAt sets the "update_at" field if the given value is not nil.
func (grc *GameRoleCreate) SetNillableUpdateAt(t *time.Time) *GameRoleCreate {
	if t != nil {
		grc.SetUpdateAt(*t)
	}
	return grc
}

// SetID sets the "id" field.
func (grc *GameRoleCreate) SetID(i int64) *GameRoleCreate {
	grc.mutation.SetID(i)
	return grc
}

// Mutation returns the GameRoleMutation object of the builder.
func (grc *GameRoleCreate) Mutation() *GameRoleMutation {
	return grc.mutation
}

// Save creates the GameRole in the database.
func (grc *GameRoleCreate) Save(ctx context.Context) (*GameRole, error) {
	grc.defaults()
	return withHooks[*GameRole, GameRoleMutation](ctx, grc.sqlSave, grc.mutation, grc.hooks)
}

// SaveX calls Save and panics if Save returns an error.
func (grc *GameRoleCreate) SaveX(ctx context.Context) *GameRole {
	v, err := grc.Save(ctx)
	if err != nil {
		panic(err)
	}
	return v
}

// Exec executes the query.
func (grc *GameRoleCreate) Exec(ctx context.Context) error {
	_, err := grc.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (grc *GameRoleCreate) ExecX(ctx context.Context) {
	if err := grc.Exec(ctx); err != nil {
		panic(err)
	}
}

// defaults sets the default values of the builder before save.
func (grc *GameRoleCreate) defaults() {
	if _, ok := grc.mutation.Level(); !ok {
		v := gamerole.DefaultLevel
		grc.mutation.SetLevel(v)
	}
	if _, ok := grc.mutation.Region(); !ok {
		v := gamerole.DefaultRegion
		grc.mutation.SetRegion(v)
	}
	if _, ok := grc.mutation.RegionName(); !ok {
		v := gamerole.DefaultRegionName
		grc.mutation.SetRegionName(v)
	}
	if _, ok := grc.mutation.NickName(); !ok {
		v := gamerole.DefaultNickName
		grc.mutation.SetNickName(v)
	}
	if _, ok := grc.mutation.CreateAt(); !ok {
		v := gamerole.DefaultCreateAt()
		grc.mutation.SetCreateAt(v)
	}
	if _, ok := grc.mutation.UpdateAt(); !ok {
		v := gamerole.DefaultUpdateAt()
		grc.mutation.SetUpdateAt(v)
	}
}

// check runs all checks and user-defined validators on the builder.
func (grc *GameRoleCreate) check() error {
	if _, ok := grc.mutation.UserID(); !ok {
		return &ValidationError{Name: "user_id", err: errors.New(`entity: missing required field "GameRole.user_id"`)}
	}
	if _, ok := grc.mutation.AccountID(); !ok {
		return &ValidationError{Name: "account_id", err: errors.New(`entity: missing required field "GameRole.account_id"`)}
	}
	if v, ok := grc.mutation.AccountID(); ok {
		if err := gamerole.AccountIDValidator(v); err != nil {
			return &ValidationError{Name: "account_id", err: fmt.Errorf(`entity: validator failed for field "GameRole.account_id": %w`, err)}
		}
	}
	if _, ok := grc.mutation.RoleID(); !ok {
		return &ValidationError{Name: "role_id", err: errors.New(`entity: missing required field "GameRole.role_id"`)}
	}
	if v, ok := grc.mutation.RoleID(); ok {
		if err := gamerole.RoleIDValidator(v); err != nil {
			return &ValidationError{Name: "role_id", err: fmt.Errorf(`entity: validator failed for field "GameRole.role_id": %w`, err)}
		}
	}
	if _, ok := grc.mutation.Level(); !ok {
		return &ValidationError{Name: "level", err: errors.New(`entity: missing required field "GameRole.level"`)}
	}
	if _, ok := grc.mutation.Region(); !ok {
		return &ValidationError{Name: "region", err: errors.New(`entity: missing required field "GameRole.region"`)}
	}
	if v, ok := grc.mutation.Region(); ok {
		if err := gamerole.RegionValidator(v); err != nil {
			return &ValidationError{Name: "region", err: fmt.Errorf(`entity: validator failed for field "GameRole.region": %w`, err)}
		}
	}
	if _, ok := grc.mutation.RegionName(); !ok {
		return &ValidationError{Name: "region_name", err: errors.New(`entity: missing required field "GameRole.region_name"`)}
	}
	if v, ok := grc.mutation.RegionName(); ok {
		if err := gamerole.RegionNameValidator(v); err != nil {
			return &ValidationError{Name: "region_name", err: fmt.Errorf(`entity: validator failed for field "GameRole.region_name": %w`, err)}
		}
	}
	if _, ok := grc.mutation.NickName(); !ok {
		return &ValidationError{Name: "nick_name", err: errors.New(`entity: missing required field "GameRole.nick_name"`)}
	}
	if v, ok := grc.mutation.NickName(); ok {
		if err := gamerole.NickNameValidator(v); err != nil {
			return &ValidationError{Name: "nick_name", err: fmt.Errorf(`entity: validator failed for field "GameRole.nick_name": %w`, err)}
		}
	}
	if _, ok := grc.mutation.CreateAt(); !ok {
		return &ValidationError{Name: "create_at", err: errors.New(`entity: missing required field "GameRole.create_at"`)}
	}
	if _, ok := grc.mutation.UpdateAt(); !ok {
		return &ValidationError{Name: "update_at", err: errors.New(`entity: missing required field "GameRole.update_at"`)}
	}
	return nil
}

func (grc *GameRoleCreate) sqlSave(ctx context.Context) (*GameRole, error) {
	if err := grc.check(); err != nil {
		return nil, err
	}
	_node, _spec := grc.createSpec()
	if err := sqlgraph.CreateNode(ctx, grc.driver, _spec); err != nil {
		if sqlgraph.IsConstraintError(err) {
			err = &ConstraintError{msg: err.Error(), wrap: err}
		}
		return nil, err
	}
	if _spec.ID.Value != _node.ID {
		id := _spec.ID.Value.(int64)
		_node.ID = int64(id)
	}
	grc.mutation.id = &_node.ID
	grc.mutation.done = true
	return _node, nil
}

func (grc *GameRoleCreate) createSpec() (*GameRole, *sqlgraph.CreateSpec) {
	var (
		_node = &GameRole{config: grc.config}
		_spec = sqlgraph.NewCreateSpec(gamerole.Table, sqlgraph.NewFieldSpec(gamerole.FieldID, field.TypeInt64))
	)
	_spec.OnConflict = grc.conflict
	if id, ok := grc.mutation.ID(); ok {
		_node.ID = id
		_spec.ID.Value = id
	}
	if value, ok := grc.mutation.UserID(); ok {
		_spec.SetField(gamerole.FieldUserID, field.TypeInt64, value)
		_node.UserID = value
	}
	if value, ok := grc.mutation.AccountID(); ok {
		_spec.SetField(gamerole.FieldAccountID, field.TypeString, value)
		_node.AccountID = value
	}
	if value, ok := grc.mutation.RoleID(); ok {
		_spec.SetField(gamerole.FieldRoleID, field.TypeString, value)
		_node.RoleID = value
	}
	if value, ok := grc.mutation.Level(); ok {
		_spec.SetField(gamerole.FieldLevel, field.TypeInt, value)
		_node.Level = value
	}
	if value, ok := grc.mutation.Region(); ok {
		_spec.SetField(gamerole.FieldRegion, field.TypeString, value)
		_node.Region = value
	}
	if value, ok := grc.mutation.RegionName(); ok {
		_spec.SetField(gamerole.FieldRegionName, field.TypeString, value)
		_node.RegionName = value
	}
	if value, ok := grc.mutation.NickName(); ok {
		_spec.SetField(gamerole.FieldNickName, field.TypeString, value)
		_node.NickName = value
	}
	if value, ok := grc.mutation.CreateAt(); ok {
		_spec.SetField(gamerole.FieldCreateAt, field.TypeTime, value)
		_node.CreateAt = value
	}
	if value, ok := grc.mutation.UpdateAt(); ok {
		_spec.SetField(gamerole.FieldUpdateAt, field.TypeTime, value)
		_node.UpdateAt = value
	}
	return _node, _spec
}

// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
//	client.GameRole.Create().
//		SetUserID(v).
//		OnConflict(
//			// Update the row with the new values
//			// the was proposed for insertion.
//			sql.ResolveWithNewValues(),
//		).
//		// Override some of the fields with custom
//		// update values.
//		Update(func(u *ent.GameRoleUpsert) {
//			SetUserID(v+v).
//		}).
//		Exec(ctx)
func (grc *GameRoleCreate) OnConflict(opts ...sql.ConflictOption) *GameRoleUpsertOne {
	grc.conflict = opts
	return &GameRoleUpsertOne{
		create: grc,
	}
}

// OnConflictColumns calls `OnConflict` and configures the columns
// as conflict target. Using this option is equivalent to using:
//
//	client.GameRole.Create().
//		OnConflict(sql.ConflictColumns(columns...)).
//		Exec(ctx)
func (grc *GameRoleCreate) OnConflictColumns(columns ...string) *GameRoleUpsertOne {
	grc.conflict = append(grc.conflict, sql.ConflictColumns(columns...))
	return &GameRoleUpsertOne{
		create: grc,
	}
}

type (
	// GameRoleUpsertOne is the builder for "upsert"-ing
	//  one GameRole node.
	GameRoleUpsertOne struct {
		create *GameRoleCreate
	}

	// GameRoleUpsert is the "OnConflict" setter.
	GameRoleUpsert struct {
		*sql.UpdateSet
	}
)

// SetUserID sets the "user_id" field.
func (u *GameRoleUpsert) SetUserID(v int64) *GameRoleUpsert {
	u.Set(gamerole.FieldUserID, v)
	return u
}

// UpdateUserID sets the "user_id" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateUserID() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldUserID)
	return u
}

// AddUserID adds v to the "user_id" field.
func (u *GameRoleUpsert) AddUserID(v int64) *GameRoleUpsert {
	u.Add(gamerole.FieldUserID, v)
	return u
}

// SetAccountID sets the "account_id" field.
func (u *GameRoleUpsert) SetAccountID(v string) *GameRoleUpsert {
	u.Set(gamerole.FieldAccountID, v)
	return u
}

// UpdateAccountID sets the "account_id" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateAccountID() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldAccountID)
	return u
}

// SetRoleID sets the "role_id" field.
func (u *GameRoleUpsert) SetRoleID(v string) *GameRoleUpsert {
	u.Set(gamerole.FieldRoleID, v)
	return u
}

// UpdateRoleID sets the "role_id" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateRoleID() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldRoleID)
	return u
}

// SetLevel sets the "level" field.
func (u *GameRoleUpsert) SetLevel(v int) *GameRoleUpsert {
	u.Set(gamerole.FieldLevel, v)
	return u
}

// UpdateLevel sets the "level" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateLevel() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldLevel)
	return u
}

// AddLevel adds v to the "level" field.
func (u *GameRoleUpsert) AddLevel(v int) *GameRoleUpsert {
	u.Add(gamerole.FieldLevel, v)
	return u
}

// SetRegion sets the "region" field.
func (u *GameRoleUpsert) SetRegion(v string) *GameRoleUpsert {
	u.Set(gamerole.FieldRegion, v)
	return u
}

// UpdateRegion sets the "region" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateRegion() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldRegion)
	return u
}

// SetRegionName sets the "region_name" field.
func (u *GameRoleUpsert) SetRegionName(v string) *GameRoleUpsert {
	u.Set(gamerole.FieldRegionName, v)
	return u
}

// UpdateRegionName sets the "region_name" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateRegionName() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldRegionName)
	return u
}

// SetNickName sets the "nick_name" field.
func (u *GameRoleUpsert) SetNickName(v string) *GameRoleUpsert {
	u.Set(gamerole.FieldNickName, v)
	return u
}

// UpdateNickName sets the "nick_name" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateNickName() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldNickName)
	return u
}

// SetUpdateAt sets the "update_at" field.
func (u *GameRoleUpsert) SetUpdateAt(v time.Time) *GameRoleUpsert {
	u.Set(gamerole.FieldUpdateAt, v)
	return u
}

// UpdateUpdateAt sets the "update_at" field to the value that was provided on create.
func (u *GameRoleUpsert) UpdateUpdateAt() *GameRoleUpsert {
	u.SetExcluded(gamerole.FieldUpdateAt)
	return u
}

// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
// Using this option is equivalent to using:
//
//	client.GameRole.Create().
//		OnConflict(
//			sql.ResolveWithNewValues(),
//			sql.ResolveWith(func(u *sql.UpdateSet) {
//				u.SetIgnore(gamerole.FieldID)
//			}),
//		).
//		Exec(ctx)
func (u *GameRoleUpsertOne) UpdateNewValues() *GameRoleUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
		if _, exists := u.create.mutation.ID(); exists {
			s.SetIgnore(gamerole.FieldID)
		}
		if _, exists := u.create.mutation.CreateAt(); exists {
			s.SetIgnore(gamerole.FieldCreateAt)
		}
	}))
	return u
}

// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
//	client.GameRole.Create().
//	    OnConflict(sql.ResolveWithIgnore()).
//	    Exec(ctx)
func (u *GameRoleUpsertOne) Ignore() *GameRoleUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
	return u
}

// DoNothing configures the conflict_action to `DO NOTHING`.
// Supported only by SQLite and PostgreSQL.
func (u *GameRoleUpsertOne) DoNothing() *GameRoleUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.DoNothing())
	return u
}

// Update allows overriding fields `UPDATE` values. See the GameRoleCreate.OnConflict
// documentation for more info.
func (u *GameRoleUpsertOne) Update(set func(*GameRoleUpsert)) *GameRoleUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
		set(&GameRoleUpsert{UpdateSet: update})
	}))
	return u
}

// SetUserID sets the "user_id" field.
func (u *GameRoleUpsertOne) SetUserID(v int64) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetUserID(v)
	})
}

// AddUserID adds v to the "user_id" field.
func (u *GameRoleUpsertOne) AddUserID(v int64) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.AddUserID(v)
	})
}

// UpdateUserID sets the "user_id" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateUserID() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateUserID()
	})
}

// SetAccountID sets the "account_id" field.
func (u *GameRoleUpsertOne) SetAccountID(v string) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetAccountID(v)
	})
}

// UpdateAccountID sets the "account_id" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateAccountID() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateAccountID()
	})
}

// SetRoleID sets the "role_id" field.
func (u *GameRoleUpsertOne) SetRoleID(v string) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetRoleID(v)
	})
}

// UpdateRoleID sets the "role_id" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateRoleID() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateRoleID()
	})
}

// SetLevel sets the "level" field.
func (u *GameRoleUpsertOne) SetLevel(v int) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetLevel(v)
	})
}

// AddLevel adds v to the "level" field.
func (u *GameRoleUpsertOne) AddLevel(v int) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.AddLevel(v)
	})
}

// UpdateLevel sets the "level" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateLevel() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateLevel()
	})
}

// SetRegion sets the "region" field.
func (u *GameRoleUpsertOne) SetRegion(v string) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetRegion(v)
	})
}

// UpdateRegion sets the "region" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateRegion() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateRegion()
	})
}

// SetRegionName sets the "region_name" field.
func (u *GameRoleUpsertOne) SetRegionName(v string) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetRegionName(v)
	})
}

// UpdateRegionName sets the "region_name" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateRegionName() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateRegionName()
	})
}

// SetNickName sets the "nick_name" field.
func (u *GameRoleUpsertOne) SetNickName(v string) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetNickName(v)
	})
}

// UpdateNickName sets the "nick_name" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateNickName() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateNickName()
	})
}

// SetUpdateAt sets the "update_at" field.
func (u *GameRoleUpsertOne) SetUpdateAt(v time.Time) *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetUpdateAt(v)
	})
}

// UpdateUpdateAt sets the "update_at" field to the value that was provided on create.
func (u *GameRoleUpsertOne) UpdateUpdateAt() *GameRoleUpsertOne {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateUpdateAt()
	})
}

// Exec executes the query.
func (u *GameRoleUpsertOne) Exec(ctx context.Context) error {
	if len(u.create.conflict) == 0 {
		return errors.New("entity: missing options for GameRoleCreate.OnConflict")
	}
	return u.create.Exec(ctx)
}

// ExecX is like Exec, but panics if an error occurs.
func (u *GameRoleUpsertOne) ExecX(ctx context.Context) {
	if err := u.create.Exec(ctx); err != nil {
		panic(err)
	}
}

// Exec executes the UPSERT query and returns the inserted/updated ID.
func (u *GameRoleUpsertOne) ID(ctx context.Context) (id int64, err error) {
	node, err := u.create.Save(ctx)
	if err != nil {
		return id, err
	}
	return node.ID, nil
}

// IDX is like ID, but panics if an error occurs.
func (u *GameRoleUpsertOne) IDX(ctx context.Context) int64 {
	id, err := u.ID(ctx)
	if err != nil {
		panic(err)
	}
	return id
}

// GameRoleCreateBulk is the builder for creating many GameRole entities in bulk.
type GameRoleCreateBulk struct {
	config
	builders []*GameRoleCreate
	conflict []sql.ConflictOption
}

// Save creates the GameRole entities in the database.
func (grcb *GameRoleCreateBulk) Save(ctx context.Context) ([]*GameRole, error) {
	specs := make([]*sqlgraph.CreateSpec, len(grcb.builders))
	nodes := make([]*GameRole, len(grcb.builders))
	mutators := make([]Mutator, len(grcb.builders))
	for i := range grcb.builders {
		func(i int, root context.Context) {
			builder := grcb.builders[i]
			builder.defaults()
			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
				mutation, ok := m.(*GameRoleMutation)
				if !ok {
					return nil, fmt.Errorf("unexpected mutation type %T", m)
				}
				if err := builder.check(); err != nil {
					return nil, err
				}
				builder.mutation = mutation
				nodes[i], specs[i] = builder.createSpec()
				var err error
				if i < len(mutators)-1 {
					_, err = mutators[i+1].Mutate(root, grcb.builders[i+1].mutation)
				} else {
					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
					spec.OnConflict = grcb.conflict
					// Invoke the actual operation on the latest mutation in the chain.
					if err = sqlgraph.BatchCreate(ctx, grcb.driver, spec); err != nil {
						if sqlgraph.IsConstraintError(err) {
							err = &ConstraintError{msg: err.Error(), wrap: err}
						}
					}
				}
				if err != nil {
					return nil, err
				}
				mutation.id = &nodes[i].ID
				if specs[i].ID.Value != nil && nodes[i].ID == 0 {
					id := specs[i].ID.Value.(int64)
					nodes[i].ID = int64(id)
				}
				mutation.done = true
				return nodes[i], nil
			})
			for i := len(builder.hooks) - 1; i >= 0; i-- {
				mut = builder.hooks[i](mut)
			}
			mutators[i] = mut
		}(i, ctx)
	}
	if len(mutators) > 0 {
		if _, err := mutators[0].Mutate(ctx, grcb.builders[0].mutation); err != nil {
			return nil, err
		}
	}
	return nodes, nil
}

// SaveX is like Save, but panics if an error occurs.
func (grcb *GameRoleCreateBulk) SaveX(ctx context.Context) []*GameRole {
	v, err := grcb.Save(ctx)
	if err != nil {
		panic(err)
	}
	return v
}

// Exec executes the query.
func (grcb *GameRoleCreateBulk) Exec(ctx context.Context) error {
	_, err := grcb.Save(ctx)
	return err
}

// ExecX is like Exec, but panics if an error occurs.
func (grcb *GameRoleCreateBulk) ExecX(ctx context.Context) {
	if err := grcb.Exec(ctx); err != nil {
		panic(err)
	}
}

// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
//	client.GameRole.CreateBulk(builders...).
//		OnConflict(
//			// Update the row with the new values
//			// the was proposed for insertion.
//			sql.ResolveWithNewValues(),
//		).
//		// Override some of the fields with custom
//		// update values.
//		Update(func(u *ent.GameRoleUpsert) {
//			SetUserID(v+v).
//		}).
//		Exec(ctx)
func (grcb *GameRoleCreateBulk) OnConflict(opts ...sql.ConflictOption) *GameRoleUpsertBulk {
	grcb.conflict = opts
	return &GameRoleUpsertBulk{
		create: grcb,
	}
}

// OnConflictColumns calls `OnConflict` and configures the columns
// as conflict target. Using this option is equivalent to using:
//
//	client.GameRole.Create().
//		OnConflict(sql.ConflictColumns(columns...)).
//		Exec(ctx)
func (grcb *GameRoleCreateBulk) OnConflictColumns(columns ...string) *GameRoleUpsertBulk {
	grcb.conflict = append(grcb.conflict, sql.ConflictColumns(columns...))
	return &GameRoleUpsertBulk{
		create: grcb,
	}
}

// GameRoleUpsertBulk is the builder for "upsert"-ing
// a bulk of GameRole nodes.
type GameRoleUpsertBulk struct {
	create *GameRoleCreateBulk
}

// UpdateNewValues updates the mutable fields using the new values that
// were set on create. Using this option is equivalent to using:
//
//	client.GameRole.Create().
//		OnConflict(
//			sql.ResolveWithNewValues(),
//			sql.ResolveWith(func(u *sql.UpdateSet) {
//				u.SetIgnore(gamerole.FieldID)
//			}),
//		).
//		Exec(ctx)
func (u *GameRoleUpsertBulk) UpdateNewValues() *GameRoleUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
		for _, b := range u.create.builders {
			if _, exists := b.mutation.ID(); exists {
				s.SetIgnore(gamerole.FieldID)
			}
			if _, exists := b.mutation.CreateAt(); exists {
				s.SetIgnore(gamerole.FieldCreateAt)
			}
		}
	}))
	return u
}

// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
//	client.GameRole.Create().
//		OnConflict(sql.ResolveWithIgnore()).
//		Exec(ctx)
func (u *GameRoleUpsertBulk) Ignore() *GameRoleUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
	return u
}

// DoNothing configures the conflict_action to `DO NOTHING`.
// Supported only by SQLite and PostgreSQL.
func (u *GameRoleUpsertBulk) DoNothing() *GameRoleUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.DoNothing())
	return u
}

// Update allows overriding fields `UPDATE` values. See the GameRoleCreateBulk.OnConflict
// documentation for more info.
func (u *GameRoleUpsertBulk) Update(set func(*GameRoleUpsert)) *GameRoleUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
		set(&GameRoleUpsert{UpdateSet: update})
	}))
	return u
}

// SetUserID sets the "user_id" field.
func (u *GameRoleUpsertBulk) SetUserID(v int64) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetUserID(v)
	})
}

// AddUserID adds v to the "user_id" field.
func (u *GameRoleUpsertBulk) AddUserID(v int64) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.AddUserID(v)
	})
}

// UpdateUserID sets the "user_id" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateUserID() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateUserID()
	})
}

// SetAccountID sets the "account_id" field.
func (u *GameRoleUpsertBulk) SetAccountID(v string) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetAccountID(v)
	})
}

// UpdateAccountID sets the "account_id" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateAccountID() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateAccountID()
	})
}

// SetRoleID sets the "role_id" field.
func (u *GameRoleUpsertBulk) SetRoleID(v string) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetRoleID(v)
	})
}

// UpdateRoleID sets the "role_id" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateRoleID() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateRoleID()
	})
}

// SetLevel sets the "level" field.
func (u *GameRoleUpsertBulk) SetLevel(v int) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetLevel(v)
	})
}

// AddLevel adds v to the "level" field.
func (u *GameRoleUpsertBulk) AddLevel(v int) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.AddLevel(v)
	})
}

// UpdateLevel sets the "level" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateLevel() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateLevel()
	})
}

// SetRegion sets the "region" field.
func (u *GameRoleUpsertBulk) SetRegion(v string) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetRegion(v)
	})
}

// UpdateRegion sets the "region" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateRegion() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateRegion()
	})
}

// SetRegionName sets the "region_name" field.
func (u *GameRoleUpsertBulk) SetRegionName(v string) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetRegionName(v)
	})
}

// UpdateRegionName sets the "region_name" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateRegionName() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateRegionName()
	})
}

// SetNickName sets the "nick_name" field.
func (u *GameRoleUpsertBulk) SetNickName(v string) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetNickName(v)
	})
}

// UpdateNickName sets the "nick_name" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateNickName() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateNickName()
	})
}

// SetUpdateAt sets the "update_at" field.
func (u *GameRoleUpsertBulk) SetUpdateAt(v time.Time) *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.SetUpdateAt(v)
	})
}

// UpdateUpdateAt sets the "update_at" field to the value that was provided on create.
func (u *GameRoleUpsertBulk) UpdateUpdateAt() *GameRoleUpsertBulk {
	return u.Update(func(s *GameRoleUpsert) {
		s.UpdateUpdateAt()
	})
}

// Exec executes the query.
func (u *GameRoleUpsertBulk) Exec(ctx context.Context) error {
	for i, b := range u.create.builders {
		if len(b.conflict) != 0 {
			return fmt.Errorf("entity: OnConflict was set for builder %d. Set it on the GameRoleCreateBulk instead", i)
		}
	}
	if len(u.create.conflict) == 0 {
		return errors.New("entity: missing options for GameRoleCreateBulk.OnConflict")
	}
	return u.create.Exec(ctx)
}

// ExecX is like Exec, but panics if an error occurs.
func (u *GameRoleUpsertBulk) ExecX(ctx context.Context) {
	if err := u.create.Exec(ctx); err != nil {
		panic(err)
	}
}