github.com/NpoolPlatform/chain-middleware@v0.0.0-20240228100535-eb1bcf896eb9/pkg/db/ent/coinbase_create.go

// Code generated by ent, DO NOT EDIT.

package ent

import (
	"context"
	"errors"
	"fmt"

	"entgo.io/ent/dialect/sql"
	"entgo.io/ent/dialect/sql/sqlgraph"
	"entgo.io/ent/schema/field"
	"github.com/NpoolPlatform/chain-middleware/pkg/db/ent/coinbase"
	"github.com/google/uuid"
	"github.com/shopspring/decimal"
)

// CoinBaseCreate is the builder for creating a CoinBase entity.
type CoinBaseCreate struct {
	config
	mutation *CoinBaseMutation
	hooks    []Hook
	conflict []sql.ConflictOption
}

// SetCreatedAt sets the "created_at" field.
func (cbc *CoinBaseCreate) SetCreatedAt(u uint32) *CoinBaseCreate {
	cbc.mutation.SetCreatedAt(u)
	return cbc
}

// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableCreatedAt(u *uint32) *CoinBaseCreate {
	if u != nil {
		cbc.SetCreatedAt(*u)
	}
	return cbc
}

// SetUpdatedAt sets the "updated_at" field.
func (cbc *CoinBaseCreate) SetUpdatedAt(u uint32) *CoinBaseCreate {
	cbc.mutation.SetUpdatedAt(u)
	return cbc
}

// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableUpdatedAt(u *uint32) *CoinBaseCreate {
	if u != nil {
		cbc.SetUpdatedAt(*u)
	}
	return cbc
}

// SetDeletedAt sets the "deleted_at" field.
func (cbc *CoinBaseCreate) SetDeletedAt(u uint32) *CoinBaseCreate {
	cbc.mutation.SetDeletedAt(u)
	return cbc
}

// SetNillableDeletedAt sets the "deleted_at" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableDeletedAt(u *uint32) *CoinBaseCreate {
	if u != nil {
		cbc.SetDeletedAt(*u)
	}
	return cbc
}

// SetEntID sets the "ent_id" field.
func (cbc *CoinBaseCreate) SetEntID(u uuid.UUID) *CoinBaseCreate {
	cbc.mutation.SetEntID(u)
	return cbc
}

// SetNillableEntID sets the "ent_id" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableEntID(u *uuid.UUID) *CoinBaseCreate {
	if u != nil {
		cbc.SetEntID(*u)
	}
	return cbc
}

// SetName sets the "name" field.
func (cbc *CoinBaseCreate) SetName(s string) *CoinBaseCreate {
	cbc.mutation.SetName(s)
	return cbc
}

// SetNillableName sets the "name" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableName(s *string) *CoinBaseCreate {
	if s != nil {
		cbc.SetName(*s)
	}
	return cbc
}

// SetLogo sets the "logo" field.
func (cbc *CoinBaseCreate) SetLogo(s string) *CoinBaseCreate {
	cbc.mutation.SetLogo(s)
	return cbc
}

// SetNillableLogo sets the "logo" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableLogo(s *string) *CoinBaseCreate {
	if s != nil {
		cbc.SetLogo(*s)
	}
	return cbc
}

// SetPresale sets the "presale" field.
func (cbc *CoinBaseCreate) SetPresale(b bool) *CoinBaseCreate {
	cbc.mutation.SetPresale(b)
	return cbc
}

// SetNillablePresale sets the "presale" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillablePresale(b *bool) *CoinBaseCreate {
	if b != nil {
		cbc.SetPresale(*b)
	}
	return cbc
}

// SetUnit sets the "unit" field.
func (cbc *CoinBaseCreate) SetUnit(s string) *CoinBaseCreate {
	cbc.mutation.SetUnit(s)
	return cbc
}

// SetNillableUnit sets the "unit" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableUnit(s *string) *CoinBaseCreate {
	if s != nil {
		cbc.SetUnit(*s)
	}
	return cbc
}

// SetEnv sets the "env" field.
func (cbc *CoinBaseCreate) SetEnv(s string) *CoinBaseCreate {
	cbc.mutation.SetEnv(s)
	return cbc
}

// SetNillableEnv sets the "env" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableEnv(s *string) *CoinBaseCreate {
	if s != nil {
		cbc.SetEnv(*s)
	}
	return cbc
}

// SetReservedAmount sets the "reserved_amount" field.
func (cbc *CoinBaseCreate) SetReservedAmount(d decimal.Decimal) *CoinBaseCreate {
	cbc.mutation.SetReservedAmount(d)
	return cbc
}

// SetNillableReservedAmount sets the "reserved_amount" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableReservedAmount(d *decimal.Decimal) *CoinBaseCreate {
	if d != nil {
		cbc.SetReservedAmount(*d)
	}
	return cbc
}

// SetForPay sets the "for_pay" field.
func (cbc *CoinBaseCreate) SetForPay(b bool) *CoinBaseCreate {
	cbc.mutation.SetForPay(b)
	return cbc
}

// SetNillableForPay sets the "for_pay" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableForPay(b *bool) *CoinBaseCreate {
	if b != nil {
		cbc.SetForPay(*b)
	}
	return cbc
}

// SetDisabled sets the "disabled" field.
func (cbc *CoinBaseCreate) SetDisabled(b bool) *CoinBaseCreate {
	cbc.mutation.SetDisabled(b)
	return cbc
}

// SetNillableDisabled sets the "disabled" field if the given value is not nil.
func (cbc *CoinBaseCreate) SetNillableDisabled(b *bool) *CoinBaseCreate {
	if b != nil {
		cbc.SetDisabled(*b)
	}
	return cbc
}

// SetID sets the "id" field.
func (cbc *CoinBaseCreate) SetID(u uint32) *CoinBaseCreate {
	cbc.mutation.SetID(u)
	return cbc
}

// Mutation returns the CoinBaseMutation object of the builder.
func (cbc *CoinBaseCreate) Mutation() *CoinBaseMutation {
	return cbc.mutation
}

// Save creates the CoinBase in the database.
func (cbc *CoinBaseCreate) Save(ctx context.Context) (*CoinBase, error) {
	var (
		err  error
		node *CoinBase
	)
	if err := cbc.defaults(); err != nil {
		return nil, err
	}
	if len(cbc.hooks) == 0 {
		if err = cbc.check(); err != nil {
			return nil, err
		}
		node, err = cbc.sqlSave(ctx)
	} else {
		var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
			mutation, ok := m.(*CoinBaseMutation)
			if !ok {
				return nil, fmt.Errorf("unexpected mutation type %T", m)
			}
			if err = cbc.check(); err != nil {
				return nil, err
			}
			cbc.mutation = mutation
			if node, err = cbc.sqlSave(ctx); err != nil {
				return nil, err
			}
			mutation.id = &node.ID
			mutation.done = true
			return node, err
		})
		for i := len(cbc.hooks) - 1; i >= 0; i-- {
			if cbc.hooks[i] == nil {
				return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
			}
			mut = cbc.hooks[i](mut)
		}
		v, err := mut.Mutate(ctx, cbc.mutation)
		if err != nil {
			return nil, err
		}
		nv, ok := v.(*CoinBase)
		if !ok {
			return nil, fmt.Errorf("unexpected node type %T returned from CoinBaseMutation", v)
		}
		node = nv
	}
	return node, err
}

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

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

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

// defaults sets the default values of the builder before save.
func (cbc *CoinBaseCreate) defaults() error {
	if _, ok := cbc.mutation.CreatedAt(); !ok {
		if coinbase.DefaultCreatedAt == nil {
			return fmt.Errorf("ent: uninitialized coinbase.DefaultCreatedAt (forgotten import ent/runtime?)")
		}
		v := coinbase.DefaultCreatedAt()
		cbc.mutation.SetCreatedAt(v)
	}
	if _, ok := cbc.mutation.UpdatedAt(); !ok {
		if coinbase.DefaultUpdatedAt == nil {
			return fmt.Errorf("ent: uninitialized coinbase.DefaultUpdatedAt (forgotten import ent/runtime?)")
		}
		v := coinbase.DefaultUpdatedAt()
		cbc.mutation.SetUpdatedAt(v)
	}
	if _, ok := cbc.mutation.DeletedAt(); !ok {
		if coinbase.DefaultDeletedAt == nil {
			return fmt.Errorf("ent: uninitialized coinbase.DefaultDeletedAt (forgotten import ent/runtime?)")
		}
		v := coinbase.DefaultDeletedAt()
		cbc.mutation.SetDeletedAt(v)
	}
	if _, ok := cbc.mutation.EntID(); !ok {
		if coinbase.DefaultEntID == nil {
			return fmt.Errorf("ent: uninitialized coinbase.DefaultEntID (forgotten import ent/runtime?)")
		}
		v := coinbase.DefaultEntID()
		cbc.mutation.SetEntID(v)
	}
	if _, ok := cbc.mutation.Name(); !ok {
		v := coinbase.DefaultName
		cbc.mutation.SetName(v)
	}
	if _, ok := cbc.mutation.Logo(); !ok {
		v := coinbase.DefaultLogo
		cbc.mutation.SetLogo(v)
	}
	if _, ok := cbc.mutation.Presale(); !ok {
		v := coinbase.DefaultPresale
		cbc.mutation.SetPresale(v)
	}
	if _, ok := cbc.mutation.Unit(); !ok {
		v := coinbase.DefaultUnit
		cbc.mutation.SetUnit(v)
	}
	if _, ok := cbc.mutation.Env(); !ok {
		v := coinbase.DefaultEnv
		cbc.mutation.SetEnv(v)
	}
	if _, ok := cbc.mutation.ReservedAmount(); !ok {
		v := coinbase.DefaultReservedAmount
		cbc.mutation.SetReservedAmount(v)
	}
	if _, ok := cbc.mutation.ForPay(); !ok {
		v := coinbase.DefaultForPay
		cbc.mutation.SetForPay(v)
	}
	if _, ok := cbc.mutation.Disabled(); !ok {
		v := coinbase.DefaultDisabled
		cbc.mutation.SetDisabled(v)
	}
	return nil
}

// check runs all checks and user-defined validators on the builder.
func (cbc *CoinBaseCreate) check() error {
	if _, ok := cbc.mutation.CreatedAt(); !ok {
		return &ValidationError{Name: "created_at", err: errors.New(`ent: missing required field "CoinBase.created_at"`)}
	}
	if _, ok := cbc.mutation.UpdatedAt(); !ok {
		return &ValidationError{Name: "updated_at", err: errors.New(`ent: missing required field "CoinBase.updated_at"`)}
	}
	if _, ok := cbc.mutation.DeletedAt(); !ok {
		return &ValidationError{Name: "deleted_at", err: errors.New(`ent: missing required field "CoinBase.deleted_at"`)}
	}
	if _, ok := cbc.mutation.EntID(); !ok {
		return &ValidationError{Name: "ent_id", err: errors.New(`ent: missing required field "CoinBase.ent_id"`)}
	}
	return nil
}

func (cbc *CoinBaseCreate) sqlSave(ctx context.Context) (*CoinBase, error) {
	_node, _spec := cbc.createSpec()
	if err := sqlgraph.CreateNode(ctx, cbc.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 = uint32(id)
	}
	return _node, nil
}

func (cbc *CoinBaseCreate) createSpec() (*CoinBase, *sqlgraph.CreateSpec) {
	var (
		_node = &CoinBase{config: cbc.config}
		_spec = &sqlgraph.CreateSpec{
			Table: coinbase.Table,
			ID: &sqlgraph.FieldSpec{
				Type:   field.TypeUint32,
				Column: coinbase.FieldID,
			},
		}
	)
	_spec.OnConflict = cbc.conflict
	if id, ok := cbc.mutation.ID(); ok {
		_node.ID = id
		_spec.ID.Value = id
	}
	if value, ok := cbc.mutation.CreatedAt(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  value,
			Column: coinbase.FieldCreatedAt,
		})
		_node.CreatedAt = value
	}
	if value, ok := cbc.mutation.UpdatedAt(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  value,
			Column: coinbase.FieldUpdatedAt,
		})
		_node.UpdatedAt = value
	}
	if value, ok := cbc.mutation.DeletedAt(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeUint32,
			Value:  value,
			Column: coinbase.FieldDeletedAt,
		})
		_node.DeletedAt = value
	}
	if value, ok := cbc.mutation.EntID(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeUUID,
			Value:  value,
			Column: coinbase.FieldEntID,
		})
		_node.EntID = value
	}
	if value, ok := cbc.mutation.Name(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: coinbase.FieldName,
		})
		_node.Name = value
	}
	if value, ok := cbc.mutation.Logo(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: coinbase.FieldLogo,
		})
		_node.Logo = value
	}
	if value, ok := cbc.mutation.Presale(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeBool,
			Value:  value,
			Column: coinbase.FieldPresale,
		})
		_node.Presale = value
	}
	if value, ok := cbc.mutation.Unit(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: coinbase.FieldUnit,
		})
		_node.Unit = value
	}
	if value, ok := cbc.mutation.Env(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeString,
			Value:  value,
			Column: coinbase.FieldEnv,
		})
		_node.Env = value
	}
	if value, ok := cbc.mutation.ReservedAmount(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeOther,
			Value:  value,
			Column: coinbase.FieldReservedAmount,
		})
		_node.ReservedAmount = value
	}
	if value, ok := cbc.mutation.ForPay(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeBool,
			Value:  value,
			Column: coinbase.FieldForPay,
		})
		_node.ForPay = value
	}
	if value, ok := cbc.mutation.Disabled(); ok {
		_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
			Type:   field.TypeBool,
			Value:  value,
			Column: coinbase.FieldDisabled,
		})
		_node.Disabled = value
	}
	return _node, _spec
}

// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
//	client.CoinBase.Create().
//		SetCreatedAt(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.CoinBaseUpsert) {
//			SetCreatedAt(v+v).
//		}).
//		Exec(ctx)
//
func (cbc *CoinBaseCreate) OnConflict(opts ...sql.ConflictOption) *CoinBaseUpsertOne {
	cbc.conflict = opts
	return &CoinBaseUpsertOne{
		create: cbc,
	}
}

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

type (
	// CoinBaseUpsertOne is the builder for "upsert"-ing
	//  one CoinBase node.
	CoinBaseUpsertOne struct {
		create *CoinBaseCreate
	}

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

// SetCreatedAt sets the "created_at" field.
func (u *CoinBaseUpsert) SetCreatedAt(v uint32) *CoinBaseUpsert {
	u.Set(coinbase.FieldCreatedAt, v)
	return u
}

// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateCreatedAt() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldCreatedAt)
	return u
}

// AddCreatedAt adds v to the "created_at" field.
func (u *CoinBaseUpsert) AddCreatedAt(v uint32) *CoinBaseUpsert {
	u.Add(coinbase.FieldCreatedAt, v)
	return u
}

// SetUpdatedAt sets the "updated_at" field.
func (u *CoinBaseUpsert) SetUpdatedAt(v uint32) *CoinBaseUpsert {
	u.Set(coinbase.FieldUpdatedAt, v)
	return u
}

// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateUpdatedAt() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldUpdatedAt)
	return u
}

// AddUpdatedAt adds v to the "updated_at" field.
func (u *CoinBaseUpsert) AddUpdatedAt(v uint32) *CoinBaseUpsert {
	u.Add(coinbase.FieldUpdatedAt, v)
	return u
}

// SetDeletedAt sets the "deleted_at" field.
func (u *CoinBaseUpsert) SetDeletedAt(v uint32) *CoinBaseUpsert {
	u.Set(coinbase.FieldDeletedAt, v)
	return u
}

// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateDeletedAt() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldDeletedAt)
	return u
}

// AddDeletedAt adds v to the "deleted_at" field.
func (u *CoinBaseUpsert) AddDeletedAt(v uint32) *CoinBaseUpsert {
	u.Add(coinbase.FieldDeletedAt, v)
	return u
}

// SetEntID sets the "ent_id" field.
func (u *CoinBaseUpsert) SetEntID(v uuid.UUID) *CoinBaseUpsert {
	u.Set(coinbase.FieldEntID, v)
	return u
}

// UpdateEntID sets the "ent_id" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateEntID() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldEntID)
	return u
}

// SetName sets the "name" field.
func (u *CoinBaseUpsert) SetName(v string) *CoinBaseUpsert {
	u.Set(coinbase.FieldName, v)
	return u
}

// UpdateName sets the "name" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateName() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldName)
	return u
}

// ClearName clears the value of the "name" field.
func (u *CoinBaseUpsert) ClearName() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldName)
	return u
}

// SetLogo sets the "logo" field.
func (u *CoinBaseUpsert) SetLogo(v string) *CoinBaseUpsert {
	u.Set(coinbase.FieldLogo, v)
	return u
}

// UpdateLogo sets the "logo" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateLogo() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldLogo)
	return u
}

// ClearLogo clears the value of the "logo" field.
func (u *CoinBaseUpsert) ClearLogo() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldLogo)
	return u
}

// SetPresale sets the "presale" field.
func (u *CoinBaseUpsert) SetPresale(v bool) *CoinBaseUpsert {
	u.Set(coinbase.FieldPresale, v)
	return u
}

// UpdatePresale sets the "presale" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdatePresale() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldPresale)
	return u
}

// ClearPresale clears the value of the "presale" field.
func (u *CoinBaseUpsert) ClearPresale() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldPresale)
	return u
}

// SetUnit sets the "unit" field.
func (u *CoinBaseUpsert) SetUnit(v string) *CoinBaseUpsert {
	u.Set(coinbase.FieldUnit, v)
	return u
}

// UpdateUnit sets the "unit" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateUnit() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldUnit)
	return u
}

// ClearUnit clears the value of the "unit" field.
func (u *CoinBaseUpsert) ClearUnit() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldUnit)
	return u
}

// SetEnv sets the "env" field.
func (u *CoinBaseUpsert) SetEnv(v string) *CoinBaseUpsert {
	u.Set(coinbase.FieldEnv, v)
	return u
}

// UpdateEnv sets the "env" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateEnv() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldEnv)
	return u
}

// ClearEnv clears the value of the "env" field.
func (u *CoinBaseUpsert) ClearEnv() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldEnv)
	return u
}

// SetReservedAmount sets the "reserved_amount" field.
func (u *CoinBaseUpsert) SetReservedAmount(v decimal.Decimal) *CoinBaseUpsert {
	u.Set(coinbase.FieldReservedAmount, v)
	return u
}

// UpdateReservedAmount sets the "reserved_amount" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateReservedAmount() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldReservedAmount)
	return u
}

// ClearReservedAmount clears the value of the "reserved_amount" field.
func (u *CoinBaseUpsert) ClearReservedAmount() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldReservedAmount)
	return u
}

// SetForPay sets the "for_pay" field.
func (u *CoinBaseUpsert) SetForPay(v bool) *CoinBaseUpsert {
	u.Set(coinbase.FieldForPay, v)
	return u
}

// UpdateForPay sets the "for_pay" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateForPay() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldForPay)
	return u
}

// ClearForPay clears the value of the "for_pay" field.
func (u *CoinBaseUpsert) ClearForPay() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldForPay)
	return u
}

// SetDisabled sets the "disabled" field.
func (u *CoinBaseUpsert) SetDisabled(v bool) *CoinBaseUpsert {
	u.Set(coinbase.FieldDisabled, v)
	return u
}

// UpdateDisabled sets the "disabled" field to the value that was provided on create.
func (u *CoinBaseUpsert) UpdateDisabled() *CoinBaseUpsert {
	u.SetExcluded(coinbase.FieldDisabled)
	return u
}

// ClearDisabled clears the value of the "disabled" field.
func (u *CoinBaseUpsert) ClearDisabled() *CoinBaseUpsert {
	u.SetNull(coinbase.FieldDisabled)
	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.CoinBase.Create().
//		OnConflict(
//			sql.ResolveWithNewValues(),
//			sql.ResolveWith(func(u *sql.UpdateSet) {
//				u.SetIgnore(coinbase.FieldID)
//			}),
//		).
//		Exec(ctx)
//
func (u *CoinBaseUpsertOne) UpdateNewValues() *CoinBaseUpsertOne {
	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(coinbase.FieldID)
		}
	}))
	return u
}

// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
//  client.CoinBase.Create().
//      OnConflict(sql.ResolveWithIgnore()).
//      Exec(ctx)
//
func (u *CoinBaseUpsertOne) Ignore() *CoinBaseUpsertOne {
	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 *CoinBaseUpsertOne) DoNothing() *CoinBaseUpsertOne {
	u.create.conflict = append(u.create.conflict, sql.DoNothing())
	return u
}

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

// SetCreatedAt sets the "created_at" field.
func (u *CoinBaseUpsertOne) SetCreatedAt(v uint32) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetCreatedAt(v)
	})
}

// AddCreatedAt adds v to the "created_at" field.
func (u *CoinBaseUpsertOne) AddCreatedAt(v uint32) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.AddCreatedAt(v)
	})
}

// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateCreatedAt() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateCreatedAt()
	})
}

// SetUpdatedAt sets the "updated_at" field.
func (u *CoinBaseUpsertOne) SetUpdatedAt(v uint32) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetUpdatedAt(v)
	})
}

// AddUpdatedAt adds v to the "updated_at" field.
func (u *CoinBaseUpsertOne) AddUpdatedAt(v uint32) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.AddUpdatedAt(v)
	})
}

// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateUpdatedAt() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateUpdatedAt()
	})
}

// SetDeletedAt sets the "deleted_at" field.
func (u *CoinBaseUpsertOne) SetDeletedAt(v uint32) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetDeletedAt(v)
	})
}

// AddDeletedAt adds v to the "deleted_at" field.
func (u *CoinBaseUpsertOne) AddDeletedAt(v uint32) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.AddDeletedAt(v)
	})
}

// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateDeletedAt() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateDeletedAt()
	})
}

// SetEntID sets the "ent_id" field.
func (u *CoinBaseUpsertOne) SetEntID(v uuid.UUID) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetEntID(v)
	})
}

// UpdateEntID sets the "ent_id" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateEntID() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateEntID()
	})
}

// SetName sets the "name" field.
func (u *CoinBaseUpsertOne) SetName(v string) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetName(v)
	})
}

// UpdateName sets the "name" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateName() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateName()
	})
}

// ClearName clears the value of the "name" field.
func (u *CoinBaseUpsertOne) ClearName() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearName()
	})
}

// SetLogo sets the "logo" field.
func (u *CoinBaseUpsertOne) SetLogo(v string) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetLogo(v)
	})
}

// UpdateLogo sets the "logo" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateLogo() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateLogo()
	})
}

// ClearLogo clears the value of the "logo" field.
func (u *CoinBaseUpsertOne) ClearLogo() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearLogo()
	})
}

// SetPresale sets the "presale" field.
func (u *CoinBaseUpsertOne) SetPresale(v bool) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetPresale(v)
	})
}

// UpdatePresale sets the "presale" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdatePresale() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdatePresale()
	})
}

// ClearPresale clears the value of the "presale" field.
func (u *CoinBaseUpsertOne) ClearPresale() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearPresale()
	})
}

// SetUnit sets the "unit" field.
func (u *CoinBaseUpsertOne) SetUnit(v string) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetUnit(v)
	})
}

// UpdateUnit sets the "unit" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateUnit() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateUnit()
	})
}

// ClearUnit clears the value of the "unit" field.
func (u *CoinBaseUpsertOne) ClearUnit() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearUnit()
	})
}

// SetEnv sets the "env" field.
func (u *CoinBaseUpsertOne) SetEnv(v string) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetEnv(v)
	})
}

// UpdateEnv sets the "env" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateEnv() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateEnv()
	})
}

// ClearEnv clears the value of the "env" field.
func (u *CoinBaseUpsertOne) ClearEnv() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearEnv()
	})
}

// SetReservedAmount sets the "reserved_amount" field.
func (u *CoinBaseUpsertOne) SetReservedAmount(v decimal.Decimal) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetReservedAmount(v)
	})
}

// UpdateReservedAmount sets the "reserved_amount" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateReservedAmount() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateReservedAmount()
	})
}

// ClearReservedAmount clears the value of the "reserved_amount" field.
func (u *CoinBaseUpsertOne) ClearReservedAmount() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearReservedAmount()
	})
}

// SetForPay sets the "for_pay" field.
func (u *CoinBaseUpsertOne) SetForPay(v bool) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetForPay(v)
	})
}

// UpdateForPay sets the "for_pay" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateForPay() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateForPay()
	})
}

// ClearForPay clears the value of the "for_pay" field.
func (u *CoinBaseUpsertOne) ClearForPay() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearForPay()
	})
}

// SetDisabled sets the "disabled" field.
func (u *CoinBaseUpsertOne) SetDisabled(v bool) *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetDisabled(v)
	})
}

// UpdateDisabled sets the "disabled" field to the value that was provided on create.
func (u *CoinBaseUpsertOne) UpdateDisabled() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateDisabled()
	})
}

// ClearDisabled clears the value of the "disabled" field.
func (u *CoinBaseUpsertOne) ClearDisabled() *CoinBaseUpsertOne {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearDisabled()
	})
}

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

// ExecX is like Exec, but panics if an error occurs.
func (u *CoinBaseUpsertOne) 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 *CoinBaseUpsertOne) ID(ctx context.Context) (id uint32, 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 *CoinBaseUpsertOne) IDX(ctx context.Context) uint32 {
	id, err := u.ID(ctx)
	if err != nil {
		panic(err)
	}
	return id
}

// CoinBaseCreateBulk is the builder for creating many CoinBase entities in bulk.
type CoinBaseCreateBulk struct {
	config
	builders []*CoinBaseCreate
	conflict []sql.ConflictOption
}

// Save creates the CoinBase entities in the database.
func (cbcb *CoinBaseCreateBulk) Save(ctx context.Context) ([]*CoinBase, error) {
	specs := make([]*sqlgraph.CreateSpec, len(cbcb.builders))
	nodes := make([]*CoinBase, len(cbcb.builders))
	mutators := make([]Mutator, len(cbcb.builders))
	for i := range cbcb.builders {
		func(i int, root context.Context) {
			builder := cbcb.builders[i]
			builder.defaults()
			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
				mutation, ok := m.(*CoinBaseMutation)
				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, cbcb.builders[i+1].mutation)
				} else {
					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
					spec.OnConflict = cbcb.conflict
					// Invoke the actual operation on the latest mutation in the chain.
					if err = sqlgraph.BatchCreate(ctx, cbcb.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 = uint32(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, cbcb.builders[0].mutation); err != nil {
			return nil, err
		}
	}
	return nodes, nil
}

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

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

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

// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
//	client.CoinBase.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.CoinBaseUpsert) {
//			SetCreatedAt(v+v).
//		}).
//		Exec(ctx)
//
func (cbcb *CoinBaseCreateBulk) OnConflict(opts ...sql.ConflictOption) *CoinBaseUpsertBulk {
	cbcb.conflict = opts
	return &CoinBaseUpsertBulk{
		create: cbcb,
	}
}

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

// CoinBaseUpsertBulk is the builder for "upsert"-ing
// a bulk of CoinBase nodes.
type CoinBaseUpsertBulk struct {
	create *CoinBaseCreateBulk
}

// UpdateNewValues updates the mutable fields using the new values that
// were set on create. Using this option is equivalent to using:
//
//	client.CoinBase.Create().
//		OnConflict(
//			sql.ResolveWithNewValues(),
//			sql.ResolveWith(func(u *sql.UpdateSet) {
//				u.SetIgnore(coinbase.FieldID)
//			}),
//		).
//		Exec(ctx)
//
func (u *CoinBaseUpsertBulk) UpdateNewValues() *CoinBaseUpsertBulk {
	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(coinbase.FieldID)
				return
			}
		}
	}))
	return u
}

// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
//	client.CoinBase.Create().
//		OnConflict(sql.ResolveWithIgnore()).
//		Exec(ctx)
//
func (u *CoinBaseUpsertBulk) Ignore() *CoinBaseUpsertBulk {
	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 *CoinBaseUpsertBulk) DoNothing() *CoinBaseUpsertBulk {
	u.create.conflict = append(u.create.conflict, sql.DoNothing())
	return u
}

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

// SetCreatedAt sets the "created_at" field.
func (u *CoinBaseUpsertBulk) SetCreatedAt(v uint32) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetCreatedAt(v)
	})
}

// AddCreatedAt adds v to the "created_at" field.
func (u *CoinBaseUpsertBulk) AddCreatedAt(v uint32) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.AddCreatedAt(v)
	})
}

// UpdateCreatedAt sets the "created_at" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateCreatedAt() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateCreatedAt()
	})
}

// SetUpdatedAt sets the "updated_at" field.
func (u *CoinBaseUpsertBulk) SetUpdatedAt(v uint32) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetUpdatedAt(v)
	})
}

// AddUpdatedAt adds v to the "updated_at" field.
func (u *CoinBaseUpsertBulk) AddUpdatedAt(v uint32) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.AddUpdatedAt(v)
	})
}

// UpdateUpdatedAt sets the "updated_at" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateUpdatedAt() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateUpdatedAt()
	})
}

// SetDeletedAt sets the "deleted_at" field.
func (u *CoinBaseUpsertBulk) SetDeletedAt(v uint32) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetDeletedAt(v)
	})
}

// AddDeletedAt adds v to the "deleted_at" field.
func (u *CoinBaseUpsertBulk) AddDeletedAt(v uint32) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.AddDeletedAt(v)
	})
}

// UpdateDeletedAt sets the "deleted_at" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateDeletedAt() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateDeletedAt()
	})
}

// SetEntID sets the "ent_id" field.
func (u *CoinBaseUpsertBulk) SetEntID(v uuid.UUID) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetEntID(v)
	})
}

// UpdateEntID sets the "ent_id" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateEntID() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateEntID()
	})
}

// SetName sets the "name" field.
func (u *CoinBaseUpsertBulk) SetName(v string) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetName(v)
	})
}

// UpdateName sets the "name" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateName() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateName()
	})
}

// ClearName clears the value of the "name" field.
func (u *CoinBaseUpsertBulk) ClearName() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearName()
	})
}

// SetLogo sets the "logo" field.
func (u *CoinBaseUpsertBulk) SetLogo(v string) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetLogo(v)
	})
}

// UpdateLogo sets the "logo" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateLogo() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateLogo()
	})
}

// ClearLogo clears the value of the "logo" field.
func (u *CoinBaseUpsertBulk) ClearLogo() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearLogo()
	})
}

// SetPresale sets the "presale" field.
func (u *CoinBaseUpsertBulk) SetPresale(v bool) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetPresale(v)
	})
}

// UpdatePresale sets the "presale" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdatePresale() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdatePresale()
	})
}

// ClearPresale clears the value of the "presale" field.
func (u *CoinBaseUpsertBulk) ClearPresale() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearPresale()
	})
}

// SetUnit sets the "unit" field.
func (u *CoinBaseUpsertBulk) SetUnit(v string) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetUnit(v)
	})
}

// UpdateUnit sets the "unit" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateUnit() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateUnit()
	})
}

// ClearUnit clears the value of the "unit" field.
func (u *CoinBaseUpsertBulk) ClearUnit() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearUnit()
	})
}

// SetEnv sets the "env" field.
func (u *CoinBaseUpsertBulk) SetEnv(v string) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetEnv(v)
	})
}

// UpdateEnv sets the "env" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateEnv() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateEnv()
	})
}

// ClearEnv clears the value of the "env" field.
func (u *CoinBaseUpsertBulk) ClearEnv() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearEnv()
	})
}

// SetReservedAmount sets the "reserved_amount" field.
func (u *CoinBaseUpsertBulk) SetReservedAmount(v decimal.Decimal) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetReservedAmount(v)
	})
}

// UpdateReservedAmount sets the "reserved_amount" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateReservedAmount() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateReservedAmount()
	})
}

// ClearReservedAmount clears the value of the "reserved_amount" field.
func (u *CoinBaseUpsertBulk) ClearReservedAmount() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearReservedAmount()
	})
}

// SetForPay sets the "for_pay" field.
func (u *CoinBaseUpsertBulk) SetForPay(v bool) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetForPay(v)
	})
}

// UpdateForPay sets the "for_pay" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateForPay() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateForPay()
	})
}

// ClearForPay clears the value of the "for_pay" field.
func (u *CoinBaseUpsertBulk) ClearForPay() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearForPay()
	})
}

// SetDisabled sets the "disabled" field.
func (u *CoinBaseUpsertBulk) SetDisabled(v bool) *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.SetDisabled(v)
	})
}

// UpdateDisabled sets the "disabled" field to the value that was provided on create.
func (u *CoinBaseUpsertBulk) UpdateDisabled() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.UpdateDisabled()
	})
}

// ClearDisabled clears the value of the "disabled" field.
func (u *CoinBaseUpsertBulk) ClearDisabled() *CoinBaseUpsertBulk {
	return u.Update(func(s *CoinBaseUpsert) {
		s.ClearDisabled()
	})
}

// Exec executes the query.
func (u *CoinBaseUpsertBulk) Exec(ctx context.Context) error {
	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 CoinBaseCreateBulk instead", i)
		}
	}
	if len(u.create.conflict) == 0 {
		return errors.New("ent: missing options for CoinBaseCreateBulk.OnConflict")
	}
	return u.create.Exec(ctx)
}

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