ent

package

Go to main page

Versions in this module

v0

v0.6.0

Jul 24, 2024

v0.5.0

Apr 11, 2024

Changes in this version

+ var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")

type UserClient

+ func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk

type WithFieldsClient

+ func (c *WithFieldsClient) MapCreateBulk(slice any, setFunc func(*WithFieldsCreate, int)) *WithFieldsCreateBulk

type WithFieldsUpdate

+ func (wfu *WithFieldsUpdate) SetNillableExisting(s *string) *WithFieldsUpdate

type WithFieldsUpdateOne

+ func (wfuo *WithFieldsUpdateOne) SetNillableExisting(s *string) *WithFieldsUpdateOne

type WithModifiedFieldClient

+ func (c *WithModifiedFieldClient) MapCreateBulk(slice any, setFunc func(*WithModifiedFieldCreate, int)) *WithModifiedFieldCreateBulk

type WithNilFieldsClient

+ func (c *WithNilFieldsClient) MapCreateBulk(slice any, setFunc func(*WithNilFieldsCreate, int)) *WithNilFieldsCreateBulk

type WithoutFieldsClient

+ func (c *WithoutFieldsClient) MapCreateBulk(slice any, setFunc func(*WithoutFieldsCreate, int)) *WithoutFieldsCreateBulk

v0.4.5

Apr 29, 2023

v0.4.4

Apr 23, 2023

v0.4.3

Apr 22, 2023

v0.4.2

Apr 20, 2023

v0.4.1

Apr 16, 2023

v0.4.0

Apr 9, 2023

Changes in this version

type User

+ func (u *User) Value(name string) (ent.Value, error)

type UserDeleteOne

+ func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne

type UserUpdateOne

+ func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne

type WithFields

+ func (wf *WithFields) Value(name string) (ent.Value, error)

type WithFieldsDeleteOne

+ func (wfdo *WithFieldsDeleteOne) Where(ps ...predicate.WithFields) *WithFieldsDeleteOne

type WithFieldsUpdateOne

+ func (wfuo *WithFieldsUpdateOne) Where(ps ...predicate.WithFields) *WithFieldsUpdateOne

type WithModifiedField

+ func (wmf *WithModifiedField) Value(name string) (ent.Value, error)

type WithModifiedFieldDeleteOne

+ func (wmfdo *WithModifiedFieldDeleteOne) Where(ps ...predicate.WithModifiedField) *WithModifiedFieldDeleteOne

type WithModifiedFieldUpdateOne

+ func (wmfuo *WithModifiedFieldUpdateOne) Where(ps ...predicate.WithModifiedField) *WithModifiedFieldUpdateOne

type WithNilFields

+ func (wnf *WithNilFields) Value(name string) (ent.Value, error)

type WithNilFieldsDeleteOne

+ func (wnfdo *WithNilFieldsDeleteOne) Where(ps ...predicate.WithNilFields) *WithNilFieldsDeleteOne

type WithNilFieldsUpdateOne

+ func (wnfuo *WithNilFieldsUpdateOne) Where(ps ...predicate.WithNilFields) *WithNilFieldsUpdateOne

type WithoutFields

+ func (wf *WithoutFields) Value(name string) (ent.Value, error)

type WithoutFieldsDeleteOne

+ func (wfdo *WithoutFieldsDeleteOne) Where(ps ...predicate.WithoutFields) *WithoutFieldsDeleteOne

type WithoutFieldsUpdateOne

+ func (wfuo *WithoutFieldsUpdateOne) Where(ps ...predicate.WithoutFields) *WithoutFieldsUpdateOne

v0.3.5

Jan 27, 2023

Changes in this version

type Client

+ func (c *Client) Intercept(interceptors ...Interceptor)

+ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error)

+ type InterceptFunc = ent.InterceptFunc

+ type Interceptor = ent.Interceptor

+ type Querier = ent.Querier

+ type QuerierFunc = ent.QuerierFunc

+ type QueryContext = ent.QueryContext

+ type TraverseFunc = ent.TraverseFunc

+ type Traverser = ent.Traverser

type UserClient

+ func (c *UserClient) Intercept(interceptors ...Interceptor)

+ func (c *UserClient) Interceptors() []Interceptor

type UserMutation

+ func (m *UserMutation) SetOp(op Op)

+ func (m *UserMutation) WhereP(ps ...func(*sql.Selector))

type WithFieldsClient

+ func (c *WithFieldsClient) Intercept(interceptors ...Interceptor)

+ func (c *WithFieldsClient) Interceptors() []Interceptor

type WithFieldsMutation

+ func (m *WithFieldsMutation) SetOp(op Op)

+ func (m *WithFieldsMutation) WhereP(ps ...func(*sql.Selector))

type WithModifiedFieldClient

+ func (c *WithModifiedFieldClient) Intercept(interceptors ...Interceptor)

+ func (c *WithModifiedFieldClient) Interceptors() []Interceptor

type WithModifiedFieldMutation

+ func (m *WithModifiedFieldMutation) SetOp(op Op)

+ func (m *WithModifiedFieldMutation) WhereP(ps ...func(*sql.Selector))

type WithNilFieldsClient

+ func (c *WithNilFieldsClient) Intercept(interceptors ...Interceptor)

+ func (c *WithNilFieldsClient) Interceptors() []Interceptor

type WithNilFieldsMutation

+ func (m *WithNilFieldsMutation) SetOp(op Op)

+ func (m *WithNilFieldsMutation) WhereP(ps ...func(*sql.Selector))

type WithoutFieldsClient

+ func (c *WithoutFieldsClient) Intercept(interceptors ...Interceptor)

+ func (c *WithoutFieldsClient) Interceptors() []Interceptor

type WithoutFieldsMutation

+ func (m *WithoutFieldsMutation) SetOp(op Op)

+ func (m *WithoutFieldsMutation) WhereP(ps ...func(*sql.Selector))

v0.3.4

Nov 6, 2022

Changes in this version

type UserQuery

+ func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect

type UserSelect

+ func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect

type WithFieldsQuery

+ func (wfq *WithFieldsQuery) Aggregate(fns ...AggregateFunc) *WithFieldsSelect

type WithFieldsSelect

+ func (wfs *WithFieldsSelect) Aggregate(fns ...AggregateFunc) *WithFieldsSelect

type WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) Aggregate(fns ...AggregateFunc) *WithModifiedFieldSelect

type WithModifiedFieldSelect

+ func (wmfs *WithModifiedFieldSelect) Aggregate(fns ...AggregateFunc) *WithModifiedFieldSelect

type WithNilFieldsQuery

+ func (wnfq *WithNilFieldsQuery) Aggregate(fns ...AggregateFunc) *WithNilFieldsSelect

type WithNilFieldsSelect

+ func (wnfs *WithNilFieldsSelect) Aggregate(fns ...AggregateFunc) *WithNilFieldsSelect

type WithoutFieldsQuery

+ func (wfq *WithoutFieldsQuery) Aggregate(fns ...AggregateFunc) *WithoutFieldsSelect

type WithoutFieldsSelect

+ func (wfs *WithoutFieldsSelect) Aggregate(fns ...AggregateFunc) *WithoutFieldsSelect

v0.3.3

Oct 4, 2022

v0.3.2

Sep 2, 2022

v0.3.1

Aug 10, 2022

v0.3.0

Jun 29, 2022

Changes in this version

type UserMutation

+ func (m *UserMutation) IDs(ctx context.Context) ([]int, error)

type WithFieldsMutation

+ func (m *WithFieldsMutation) IDs(ctx context.Context) ([]int, error)

type WithModifiedFieldMutation

+ func (m *WithModifiedFieldMutation) IDs(ctx context.Context) ([]int, error)

type WithNilFieldsMutation

+ func (m *WithNilFieldsMutation) IDs(ctx context.Context) ([]int, error)

type WithoutFieldsMutation

+ func (m *WithoutFieldsMutation) IDs(ctx context.Context) ([]int, error)

v0.2.0

Nov 20, 2021

Changes in this version

type UserCreate

+ func (uc *UserCreate) Exec(ctx context.Context) error

+ func (uc *UserCreate) ExecX(ctx context.Context)

type UserCreateBulk

+ func (ucb *UserCreateBulk) Exec(ctx context.Context) error

+ func (ucb *UserCreateBulk) ExecX(ctx context.Context)

type UserMutation

+ func (m *UserMutation) Where(ps ...predicate.User)

type WithFieldsCreate

+ func (wfc *WithFieldsCreate) Exec(ctx context.Context) error

+ func (wfc *WithFieldsCreate) ExecX(ctx context.Context)

type WithFieldsCreateBulk

+ func (wfcb *WithFieldsCreateBulk) Exec(ctx context.Context) error

+ func (wfcb *WithFieldsCreateBulk) ExecX(ctx context.Context)

type WithFieldsMutation

+ func (m *WithFieldsMutation) Where(ps ...predicate.WithFields)

type WithModifiedFieldCreate

+ func (wmfc *WithModifiedFieldCreate) Exec(ctx context.Context) error

+ func (wmfc *WithModifiedFieldCreate) ExecX(ctx context.Context)

type WithModifiedFieldCreateBulk

+ func (wmfcb *WithModifiedFieldCreateBulk) Exec(ctx context.Context) error

+ func (wmfcb *WithModifiedFieldCreateBulk) ExecX(ctx context.Context)

type WithModifiedFieldMutation

+ func (m *WithModifiedFieldMutation) Where(ps ...predicate.WithModifiedField)

type WithNilFieldsCreate

+ func (wnfc *WithNilFieldsCreate) Exec(ctx context.Context) error

+ func (wnfc *WithNilFieldsCreate) ExecX(ctx context.Context)

type WithNilFieldsCreateBulk

+ func (wnfcb *WithNilFieldsCreateBulk) Exec(ctx context.Context) error

+ func (wnfcb *WithNilFieldsCreateBulk) ExecX(ctx context.Context)

type WithNilFieldsMutation

+ func (m *WithNilFieldsMutation) Where(ps ...predicate.WithNilFields)

type WithoutFieldsCreate

+ func (wfc *WithoutFieldsCreate) Exec(ctx context.Context) error

+ func (wfc *WithoutFieldsCreate) ExecX(ctx context.Context)

type WithoutFieldsCreateBulk

+ func (wfcb *WithoutFieldsCreateBulk) Exec(ctx context.Context) error

+ func (wfcb *WithoutFieldsCreateBulk) ExecX(ctx context.Context)

type WithoutFieldsMutation

+ func (m *WithoutFieldsMutation) Where(ps ...predicate.WithoutFields)

v0.1.0

Aug 17, 2021

Changes in this version

+ const OpCreate

+ const OpDelete

+ const OpDeleteOne

+ const OpUpdate

+ const OpUpdateOne

+ const TypeUser

+ const TypeWithFields

+ const TypeWithModifiedField

+ const TypeWithNilFields

+ const TypeWithoutFields

+ func IsConstraintError(err error) bool

+ func IsNotFound(err error) bool

+ func IsNotLoaded(err error) bool

+ func IsNotSingular(err error) bool

+ func IsValidationError(err error) bool

+ func MaskNotFound(err error) error

+ func NewContext(parent context.Context, c *Client) context.Context

+ func NewTxContext(parent context.Context, tx *Tx) context.Context

+ type AggregateFunc func(*sql.Selector) string

+ func As(fn AggregateFunc, end string) AggregateFunc

+ func Count() AggregateFunc

+ func Max(field string) AggregateFunc

+ func Mean(field string) AggregateFunc

+ func Min(field string) AggregateFunc

+ func Sum(field string) AggregateFunc

+ type Client struct

+ Schema *migrate.Schema

+ User *UserClient

+ WithFields *WithFieldsClient

+ WithModifiedField *WithModifiedFieldClient

+ WithNilFields *WithNilFieldsClient

+ WithoutFields *WithoutFieldsClient

+ func FromContext(ctx context.Context) *Client

+ func NewClient(opts ...Option) *Client

+ func Open(driverName, dataSourceName string, options ...Option) (*Client, error)

+ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)

+ func (c *Client) Close() error

+ func (c *Client) Debug() *Client

+ func (c *Client) Tx(ctx context.Context) (*Tx, error)

+ func (c *Client) Use(hooks ...Hook)

+ type CommitFunc func(context.Context, *Tx) error

+ func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error

+ type CommitHook func(Committer) Committer

+ type Committer interface

+ Commit func(context.Context, *Tx) error

+ type ConstraintError struct

+ func (e *ConstraintError) Unwrap() error

+ func (e ConstraintError) Error() string

+ type Hook = ent.Hook

+ type MutateFunc = ent.MutateFunc

+ type Mutation = ent.Mutation

+ type Mutator = ent.Mutator

+ type NotFoundError struct

+ func (e *NotFoundError) Error() string

+ type NotLoadedError struct

+ func (e *NotLoadedError) Error() string

+ type NotSingularError struct

+ func (e *NotSingularError) Error() string

+ type Op = ent.Op

+ type Option func(*config)

+ func Debug() Option

+ func Driver(driver dialect.Driver) Option

+ func Log(fn func(...interface{})) Option

+ type OrderFunc func(*sql.Selector)

+ func Asc(fields ...string) OrderFunc

+ func Desc(fields ...string) OrderFunc

+ type Policy = ent.Policy

+ type Query = ent.Query

+ type RollbackFunc func(context.Context, *Tx) error

+ func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error

+ type RollbackHook func(Rollbacker) Rollbacker

+ type Rollbacker interface

+ Rollback func(context.Context, *Tx) error

+ type Tx struct

+ User *UserClient

+ WithFields *WithFieldsClient

+ WithModifiedField *WithModifiedFieldClient

+ WithNilFields *WithNilFieldsClient

+ WithoutFields *WithoutFieldsClient

+ func TxFromContext(ctx context.Context) *Tx

+ func (tx *Tx) Client() *Client

+ func (tx *Tx) Commit() error

+ func (tx *Tx) OnCommit(f CommitHook)

+ func (tx *Tx) OnRollback(f RollbackHook)

+ func (tx *Tx) Rollback() error

+ type User struct

+ ID int

+ func (u *User) String() string

+ func (u *User) Unwrap() *User

+ func (u *User) Update() *UserUpdateOne

+ type UserClient struct

+ func NewUserClient(c config) *UserClient

+ func (c *UserClient) Create() *UserCreate

+ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk

+ func (c *UserClient) Delete() *UserDelete

+ func (c *UserClient) DeleteOne(u *User) *UserDeleteOne

+ func (c *UserClient) DeleteOneID(id int) *UserDeleteOne

+ func (c *UserClient) Get(ctx context.Context, id int) (*User, error)

+ func (c *UserClient) GetX(ctx context.Context, id int) *User

+ func (c *UserClient) Hooks() []Hook

+ func (c *UserClient) Query() *UserQuery

+ func (c *UserClient) Update() *UserUpdate

+ func (c *UserClient) UpdateOne(u *User) *UserUpdateOne

+ func (c *UserClient) UpdateOneID(id int) *UserUpdateOne

+ func (c *UserClient) Use(hooks ...Hook)

+ type UserCreate struct

+ func (uc *UserCreate) Mutation() *UserMutation

+ func (uc *UserCreate) Save(ctx context.Context) (*User, error)

+ func (uc *UserCreate) SaveX(ctx context.Context) *User

+ type UserCreateBulk struct

+ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error)

+ func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User

+ type UserDelete struct

+ func (ud *UserDelete) Exec(ctx context.Context) (int, error)

+ func (ud *UserDelete) ExecX(ctx context.Context) int

+ func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete

+ type UserDeleteOne struct

+ func (udo *UserDeleteOne) Exec(ctx context.Context) error

+ func (udo *UserDeleteOne) ExecX(ctx context.Context)

+ type UserGroupBy struct

+ func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy

+ func (ugb *UserGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (ugb *UserGroupBy) BoolX(ctx context.Context) bool

+ func (ugb *UserGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (ugb *UserGroupBy) BoolsX(ctx context.Context) []bool

+ func (ugb *UserGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (ugb *UserGroupBy) Float64X(ctx context.Context) float64

+ func (ugb *UserGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (ugb *UserGroupBy) Float64sX(ctx context.Context) []float64

+ func (ugb *UserGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (ugb *UserGroupBy) IntX(ctx context.Context) int

+ func (ugb *UserGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (ugb *UserGroupBy) IntsX(ctx context.Context) []int

+ func (ugb *UserGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (ugb *UserGroupBy) ScanX(ctx context.Context, v interface{})

+ func (ugb *UserGroupBy) String(ctx context.Context) (_ string, err error)

+ func (ugb *UserGroupBy) StringX(ctx context.Context) string

+ func (ugb *UserGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (ugb *UserGroupBy) StringsX(ctx context.Context) []string

+ type UserMutation struct

+ func (m *UserMutation) AddField(name string, value ent.Value) error

+ func (m *UserMutation) AddedEdges() []string

+ func (m *UserMutation) AddedField(name string) (ent.Value, bool)

+ func (m *UserMutation) AddedFields() []string

+ func (m *UserMutation) AddedIDs(name string) []ent.Value

+ func (m *UserMutation) ClearEdge(name string) error

+ func (m *UserMutation) ClearField(name string) error

+ func (m *UserMutation) ClearedEdges() []string

+ func (m *UserMutation) ClearedFields() []string

+ func (m *UserMutation) EdgeCleared(name string) bool

+ func (m *UserMutation) Field(name string) (ent.Value, bool)

+ func (m *UserMutation) FieldCleared(name string) bool

+ func (m *UserMutation) Fields() []string

+ func (m *UserMutation) ID() (id int, exists bool)

+ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *UserMutation) Op() Op

+ func (m *UserMutation) RemovedEdges() []string

+ func (m *UserMutation) RemovedIDs(name string) []ent.Value

+ func (m *UserMutation) ResetEdge(name string) error

+ func (m *UserMutation) ResetField(name string) error

+ func (m *UserMutation) SetField(name string, value ent.Value) error

+ func (m *UserMutation) Type() string

+ func (m UserMutation) Client() *Client

+ func (m UserMutation) Tx() (*Tx, error)

+ type UserQuery struct

+ func (uq *UserQuery) All(ctx context.Context) ([]*User, error)

+ func (uq *UserQuery) AllX(ctx context.Context) []*User

+ func (uq *UserQuery) Clone() *UserQuery

+ func (uq *UserQuery) Count(ctx context.Context) (int, error)

+ func (uq *UserQuery) CountX(ctx context.Context) int

+ func (uq *UserQuery) Exist(ctx context.Context) (bool, error)

+ func (uq *UserQuery) ExistX(ctx context.Context) bool

+ func (uq *UserQuery) First(ctx context.Context) (*User, error)

+ func (uq *UserQuery) FirstID(ctx context.Context) (id int, err error)

+ func (uq *UserQuery) FirstIDX(ctx context.Context) int

+ func (uq *UserQuery) FirstX(ctx context.Context) *User

+ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy

+ func (uq *UserQuery) IDs(ctx context.Context) ([]int, error)

+ func (uq *UserQuery) IDsX(ctx context.Context) []int

+ func (uq *UserQuery) Limit(limit int) *UserQuery

+ func (uq *UserQuery) Offset(offset int) *UserQuery

+ func (uq *UserQuery) Only(ctx context.Context) (*User, error)

+ func (uq *UserQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (uq *UserQuery) OnlyIDX(ctx context.Context) int

+ func (uq *UserQuery) OnlyX(ctx context.Context) *User

+ func (uq *UserQuery) Order(o ...OrderFunc) *UserQuery

+ func (uq *UserQuery) Select(field string, fields ...string) *UserSelect

+ func (uq *UserQuery) Unique(unique bool) *UserQuery

+ func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery

+ type UserSelect struct

+ func (us *UserSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (us *UserSelect) BoolX(ctx context.Context) bool

+ func (us *UserSelect) Bools(ctx context.Context) ([]bool, error)

+ func (us *UserSelect) BoolsX(ctx context.Context) []bool

+ func (us *UserSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (us *UserSelect) Float64X(ctx context.Context) float64

+ func (us *UserSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (us *UserSelect) Float64sX(ctx context.Context) []float64

+ func (us *UserSelect) Int(ctx context.Context) (_ int, err error)

+ func (us *UserSelect) IntX(ctx context.Context) int

+ func (us *UserSelect) Ints(ctx context.Context) ([]int, error)

+ func (us *UserSelect) IntsX(ctx context.Context) []int

+ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error

+ func (us *UserSelect) ScanX(ctx context.Context, v interface{})

+ func (us *UserSelect) String(ctx context.Context) (_ string, err error)

+ func (us *UserSelect) StringX(ctx context.Context) string

+ func (us *UserSelect) Strings(ctx context.Context) ([]string, error)

+ func (us *UserSelect) StringsX(ctx context.Context) []string

+ type UserUpdate struct

+ func (uu *UserUpdate) Exec(ctx context.Context) error

+ func (uu *UserUpdate) ExecX(ctx context.Context)

+ func (uu *UserUpdate) Mutation() *UserMutation

+ func (uu *UserUpdate) Save(ctx context.Context) (int, error)

+ func (uu *UserUpdate) SaveX(ctx context.Context) int

+ func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate

+ type UserUpdateOne struct

+ func (uuo *UserUpdateOne) Exec(ctx context.Context) error

+ func (uuo *UserUpdateOne) ExecX(ctx context.Context)

+ func (uuo *UserUpdateOne) Mutation() *UserMutation

+ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error)

+ func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User

+ func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne

+ type Users []*User

+ type ValidationError struct

+ Name string

+ func (e *ValidationError) Error() string

+ func (e *ValidationError) Unwrap() error

+ type Value = ent.Value

+ type WithFields struct

+ Existing string

+ ID int

+ func (wf *WithFields) String() string

+ func (wf *WithFields) Unwrap() *WithFields

+ func (wf *WithFields) Update() *WithFieldsUpdateOne

+ type WithFieldsClient struct

+ func NewWithFieldsClient(c config) *WithFieldsClient

+ func (c *WithFieldsClient) Create() *WithFieldsCreate

+ func (c *WithFieldsClient) CreateBulk(builders ...*WithFieldsCreate) *WithFieldsCreateBulk

+ func (c *WithFieldsClient) Delete() *WithFieldsDelete

+ func (c *WithFieldsClient) DeleteOne(wf *WithFields) *WithFieldsDeleteOne

+ func (c *WithFieldsClient) DeleteOneID(id int) *WithFieldsDeleteOne

+ func (c *WithFieldsClient) Get(ctx context.Context, id int) (*WithFields, error)

+ func (c *WithFieldsClient) GetX(ctx context.Context, id int) *WithFields

+ func (c *WithFieldsClient) Hooks() []Hook

+ func (c *WithFieldsClient) Query() *WithFieldsQuery

+ func (c *WithFieldsClient) Update() *WithFieldsUpdate

+ func (c *WithFieldsClient) UpdateOne(wf *WithFields) *WithFieldsUpdateOne

+ func (c *WithFieldsClient) UpdateOneID(id int) *WithFieldsUpdateOne

+ func (c *WithFieldsClient) Use(hooks ...Hook)

+ type WithFieldsCreate struct

+ func (wfc *WithFieldsCreate) Mutation() *WithFieldsMutation

+ func (wfc *WithFieldsCreate) Save(ctx context.Context) (*WithFields, error)

+ func (wfc *WithFieldsCreate) SaveX(ctx context.Context) *WithFields

+ func (wfc *WithFieldsCreate) SetExisting(s string) *WithFieldsCreate

+ type WithFieldsCreateBulk struct

+ func (wfcb *WithFieldsCreateBulk) Save(ctx context.Context) ([]*WithFields, error)

+ func (wfcb *WithFieldsCreateBulk) SaveX(ctx context.Context) []*WithFields

+ type WithFieldsDelete struct

+ func (wfd *WithFieldsDelete) Exec(ctx context.Context) (int, error)

+ func (wfd *WithFieldsDelete) ExecX(ctx context.Context) int

+ func (wfd *WithFieldsDelete) Where(ps ...predicate.WithFields) *WithFieldsDelete

+ type WithFieldsDeleteOne struct

+ func (wfdo *WithFieldsDeleteOne) Exec(ctx context.Context) error

+ func (wfdo *WithFieldsDeleteOne) ExecX(ctx context.Context)

+ type WithFieldsGroupBy struct

+ func (wfgb *WithFieldsGroupBy) Aggregate(fns ...AggregateFunc) *WithFieldsGroupBy

+ func (wfgb *WithFieldsGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (wfgb *WithFieldsGroupBy) BoolX(ctx context.Context) bool

+ func (wfgb *WithFieldsGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (wfgb *WithFieldsGroupBy) BoolsX(ctx context.Context) []bool

+ func (wfgb *WithFieldsGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (wfgb *WithFieldsGroupBy) Float64X(ctx context.Context) float64

+ func (wfgb *WithFieldsGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (wfgb *WithFieldsGroupBy) Float64sX(ctx context.Context) []float64

+ func (wfgb *WithFieldsGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (wfgb *WithFieldsGroupBy) IntX(ctx context.Context) int

+ func (wfgb *WithFieldsGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (wfgb *WithFieldsGroupBy) IntsX(ctx context.Context) []int

+ func (wfgb *WithFieldsGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (wfgb *WithFieldsGroupBy) ScanX(ctx context.Context, v interface{})

+ func (wfgb *WithFieldsGroupBy) String(ctx context.Context) (_ string, err error)

+ func (wfgb *WithFieldsGroupBy) StringX(ctx context.Context) string

+ func (wfgb *WithFieldsGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (wfgb *WithFieldsGroupBy) StringsX(ctx context.Context) []string

+ type WithFieldsMutation struct

+ func (m *WithFieldsMutation) AddField(name string, value ent.Value) error

+ func (m *WithFieldsMutation) AddedEdges() []string

+ func (m *WithFieldsMutation) AddedField(name string) (ent.Value, bool)

+ func (m *WithFieldsMutation) AddedFields() []string

+ func (m *WithFieldsMutation) AddedIDs(name string) []ent.Value

+ func (m *WithFieldsMutation) ClearEdge(name string) error

+ func (m *WithFieldsMutation) ClearField(name string) error

+ func (m *WithFieldsMutation) ClearedEdges() []string

+ func (m *WithFieldsMutation) ClearedFields() []string

+ func (m *WithFieldsMutation) EdgeCleared(name string) bool

+ func (m *WithFieldsMutation) Existing() (r string, exists bool)

+ func (m *WithFieldsMutation) Field(name string) (ent.Value, bool)

+ func (m *WithFieldsMutation) FieldCleared(name string) bool

+ func (m *WithFieldsMutation) Fields() []string

+ func (m *WithFieldsMutation) ID() (id int, exists bool)

+ func (m *WithFieldsMutation) OldExisting(ctx context.Context) (v string, err error)

+ func (m *WithFieldsMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *WithFieldsMutation) Op() Op

+ func (m *WithFieldsMutation) RemovedEdges() []string

+ func (m *WithFieldsMutation) RemovedIDs(name string) []ent.Value

+ func (m *WithFieldsMutation) ResetEdge(name string) error

+ func (m *WithFieldsMutation) ResetExisting()

+ func (m *WithFieldsMutation) ResetField(name string) error

+ func (m *WithFieldsMutation) SetExisting(s string)

+ func (m *WithFieldsMutation) SetField(name string, value ent.Value) error

+ func (m *WithFieldsMutation) Type() string

+ func (m WithFieldsMutation) Client() *Client

+ func (m WithFieldsMutation) Tx() (*Tx, error)

+ type WithFieldsQuery struct

+ func (wfq *WithFieldsQuery) All(ctx context.Context) ([]*WithFields, error)

+ func (wfq *WithFieldsQuery) AllX(ctx context.Context) []*WithFields

+ func (wfq *WithFieldsQuery) Clone() *WithFieldsQuery

+ func (wfq *WithFieldsQuery) Count(ctx context.Context) (int, error)

+ func (wfq *WithFieldsQuery) CountX(ctx context.Context) int

+ func (wfq *WithFieldsQuery) Exist(ctx context.Context) (bool, error)

+ func (wfq *WithFieldsQuery) ExistX(ctx context.Context) bool

+ func (wfq *WithFieldsQuery) First(ctx context.Context) (*WithFields, error)

+ func (wfq *WithFieldsQuery) FirstID(ctx context.Context) (id int, err error)

+ func (wfq *WithFieldsQuery) FirstIDX(ctx context.Context) int

+ func (wfq *WithFieldsQuery) FirstX(ctx context.Context) *WithFields

+ func (wfq *WithFieldsQuery) GroupBy(field string, fields ...string) *WithFieldsGroupBy

+ func (wfq *WithFieldsQuery) IDs(ctx context.Context) ([]int, error)

+ func (wfq *WithFieldsQuery) IDsX(ctx context.Context) []int

+ func (wfq *WithFieldsQuery) Limit(limit int) *WithFieldsQuery

+ func (wfq *WithFieldsQuery) Offset(offset int) *WithFieldsQuery

+ func (wfq *WithFieldsQuery) Only(ctx context.Context) (*WithFields, error)

+ func (wfq *WithFieldsQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (wfq *WithFieldsQuery) OnlyIDX(ctx context.Context) int

+ func (wfq *WithFieldsQuery) OnlyX(ctx context.Context) *WithFields

+ func (wfq *WithFieldsQuery) Order(o ...OrderFunc) *WithFieldsQuery

+ func (wfq *WithFieldsQuery) Select(field string, fields ...string) *WithFieldsSelect

+ func (wfq *WithFieldsQuery) Unique(unique bool) *WithFieldsQuery

+ func (wfq *WithFieldsQuery) Where(ps ...predicate.WithFields) *WithFieldsQuery

+ type WithFieldsSelect struct

+ func (wfs *WithFieldsSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (wfs *WithFieldsSelect) BoolX(ctx context.Context) bool

+ func (wfs *WithFieldsSelect) Bools(ctx context.Context) ([]bool, error)

+ func (wfs *WithFieldsSelect) BoolsX(ctx context.Context) []bool

+ func (wfs *WithFieldsSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (wfs *WithFieldsSelect) Float64X(ctx context.Context) float64

+ func (wfs *WithFieldsSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (wfs *WithFieldsSelect) Float64sX(ctx context.Context) []float64

+ func (wfs *WithFieldsSelect) Int(ctx context.Context) (_ int, err error)

+ func (wfs *WithFieldsSelect) IntX(ctx context.Context) int

+ func (wfs *WithFieldsSelect) Ints(ctx context.Context) ([]int, error)

+ func (wfs *WithFieldsSelect) IntsX(ctx context.Context) []int

+ func (wfs *WithFieldsSelect) Scan(ctx context.Context, v interface{}) error

+ func (wfs *WithFieldsSelect) ScanX(ctx context.Context, v interface{})

+ func (wfs *WithFieldsSelect) String(ctx context.Context) (_ string, err error)

+ func (wfs *WithFieldsSelect) StringX(ctx context.Context) string

+ func (wfs *WithFieldsSelect) Strings(ctx context.Context) ([]string, error)

+ func (wfs *WithFieldsSelect) StringsX(ctx context.Context) []string

+ type WithFieldsSlice []*WithFields

+ type WithFieldsUpdate struct

+ func (wfu *WithFieldsUpdate) Exec(ctx context.Context) error

+ func (wfu *WithFieldsUpdate) ExecX(ctx context.Context)

+ func (wfu *WithFieldsUpdate) Mutation() *WithFieldsMutation

+ func (wfu *WithFieldsUpdate) Save(ctx context.Context) (int, error)

+ func (wfu *WithFieldsUpdate) SaveX(ctx context.Context) int

+ func (wfu *WithFieldsUpdate) SetExisting(s string) *WithFieldsUpdate

+ func (wfu *WithFieldsUpdate) Where(ps ...predicate.WithFields) *WithFieldsUpdate

+ type WithFieldsUpdateOne struct

+ func (wfuo *WithFieldsUpdateOne) Exec(ctx context.Context) error

+ func (wfuo *WithFieldsUpdateOne) ExecX(ctx context.Context)

+ func (wfuo *WithFieldsUpdateOne) Mutation() *WithFieldsMutation

+ func (wfuo *WithFieldsUpdateOne) Save(ctx context.Context) (*WithFields, error)

+ func (wfuo *WithFieldsUpdateOne) SaveX(ctx context.Context) *WithFields

+ func (wfuo *WithFieldsUpdateOne) Select(field string, fields ...string) *WithFieldsUpdateOne

+ func (wfuo *WithFieldsUpdateOne) SetExisting(s string) *WithFieldsUpdateOne

+ type WithModifiedField struct

+ Edges WithModifiedFieldEdges

+ ID int

+ Name string

+ func (wmf *WithModifiedField) QueryOwner() *UserQuery

+ func (wmf *WithModifiedField) String() string

+ func (wmf *WithModifiedField) Unwrap() *WithModifiedField

+ func (wmf *WithModifiedField) Update() *WithModifiedFieldUpdateOne

+ type WithModifiedFieldClient struct

+ func NewWithModifiedFieldClient(c config) *WithModifiedFieldClient

+ func (c *WithModifiedFieldClient) Create() *WithModifiedFieldCreate

+ func (c *WithModifiedFieldClient) CreateBulk(builders ...*WithModifiedFieldCreate) *WithModifiedFieldCreateBulk

+ func (c *WithModifiedFieldClient) Delete() *WithModifiedFieldDelete

+ func (c *WithModifiedFieldClient) DeleteOne(wmf *WithModifiedField) *WithModifiedFieldDeleteOne

+ func (c *WithModifiedFieldClient) DeleteOneID(id int) *WithModifiedFieldDeleteOne

+ func (c *WithModifiedFieldClient) Get(ctx context.Context, id int) (*WithModifiedField, error)

+ func (c *WithModifiedFieldClient) GetX(ctx context.Context, id int) *WithModifiedField

+ func (c *WithModifiedFieldClient) Hooks() []Hook

+ func (c *WithModifiedFieldClient) Query() *WithModifiedFieldQuery

+ func (c *WithModifiedFieldClient) QueryOwner(wmf *WithModifiedField) *UserQuery

+ func (c *WithModifiedFieldClient) Update() *WithModifiedFieldUpdate

+ func (c *WithModifiedFieldClient) UpdateOne(wmf *WithModifiedField) *WithModifiedFieldUpdateOne

+ func (c *WithModifiedFieldClient) UpdateOneID(id int) *WithModifiedFieldUpdateOne

+ func (c *WithModifiedFieldClient) Use(hooks ...Hook)

+ type WithModifiedFieldCreate struct

+ func (wmfc *WithModifiedFieldCreate) Mutation() *WithModifiedFieldMutation

+ func (wmfc *WithModifiedFieldCreate) Save(ctx context.Context) (*WithModifiedField, error)

+ func (wmfc *WithModifiedFieldCreate) SaveX(ctx context.Context) *WithModifiedField

+ func (wmfc *WithModifiedFieldCreate) SetName(s string) *WithModifiedFieldCreate

+ func (wmfc *WithModifiedFieldCreate) SetNillableOwnerID(id *int) *WithModifiedFieldCreate

+ func (wmfc *WithModifiedFieldCreate) SetOwner(u *User) *WithModifiedFieldCreate

+ func (wmfc *WithModifiedFieldCreate) SetOwnerID(id int) *WithModifiedFieldCreate

+ type WithModifiedFieldCreateBulk struct

+ func (wmfcb *WithModifiedFieldCreateBulk) Save(ctx context.Context) ([]*WithModifiedField, error)

+ func (wmfcb *WithModifiedFieldCreateBulk) SaveX(ctx context.Context) []*WithModifiedField

+ type WithModifiedFieldDelete struct

+ func (wmfd *WithModifiedFieldDelete) Exec(ctx context.Context) (int, error)

+ func (wmfd *WithModifiedFieldDelete) ExecX(ctx context.Context) int

+ func (wmfd *WithModifiedFieldDelete) Where(ps ...predicate.WithModifiedField) *WithModifiedFieldDelete

+ type WithModifiedFieldDeleteOne struct

+ func (wmfdo *WithModifiedFieldDeleteOne) Exec(ctx context.Context) error

+ func (wmfdo *WithModifiedFieldDeleteOne) ExecX(ctx context.Context)

+ type WithModifiedFieldEdges struct

+ Owner *User

+ func (e WithModifiedFieldEdges) OwnerOrErr() (*User, error)

+ type WithModifiedFieldGroupBy struct

+ func (wmfgb *WithModifiedFieldGroupBy) Aggregate(fns ...AggregateFunc) *WithModifiedFieldGroupBy

+ func (wmfgb *WithModifiedFieldGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (wmfgb *WithModifiedFieldGroupBy) BoolX(ctx context.Context) bool

+ func (wmfgb *WithModifiedFieldGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (wmfgb *WithModifiedFieldGroupBy) BoolsX(ctx context.Context) []bool

+ func (wmfgb *WithModifiedFieldGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (wmfgb *WithModifiedFieldGroupBy) Float64X(ctx context.Context) float64

+ func (wmfgb *WithModifiedFieldGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (wmfgb *WithModifiedFieldGroupBy) Float64sX(ctx context.Context) []float64

+ func (wmfgb *WithModifiedFieldGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (wmfgb *WithModifiedFieldGroupBy) IntX(ctx context.Context) int

+ func (wmfgb *WithModifiedFieldGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (wmfgb *WithModifiedFieldGroupBy) IntsX(ctx context.Context) []int

+ func (wmfgb *WithModifiedFieldGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (wmfgb *WithModifiedFieldGroupBy) ScanX(ctx context.Context, v interface{})

+ func (wmfgb *WithModifiedFieldGroupBy) String(ctx context.Context) (_ string, err error)

+ func (wmfgb *WithModifiedFieldGroupBy) StringX(ctx context.Context) string

+ func (wmfgb *WithModifiedFieldGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (wmfgb *WithModifiedFieldGroupBy) StringsX(ctx context.Context) []string

+ type WithModifiedFieldMutation struct

+ func (m *WithModifiedFieldMutation) AddField(name string, value ent.Value) error

+ func (m *WithModifiedFieldMutation) AddedEdges() []string

+ func (m *WithModifiedFieldMutation) AddedField(name string) (ent.Value, bool)

+ func (m *WithModifiedFieldMutation) AddedFields() []string

+ func (m *WithModifiedFieldMutation) AddedIDs(name string) []ent.Value

+ func (m *WithModifiedFieldMutation) ClearEdge(name string) error

+ func (m *WithModifiedFieldMutation) ClearField(name string) error

+ func (m *WithModifiedFieldMutation) ClearOwner()

+ func (m *WithModifiedFieldMutation) ClearedEdges() []string

+ func (m *WithModifiedFieldMutation) ClearedFields() []string

+ func (m *WithModifiedFieldMutation) EdgeCleared(name string) bool

+ func (m *WithModifiedFieldMutation) Field(name string) (ent.Value, bool)

+ func (m *WithModifiedFieldMutation) FieldCleared(name string) bool

+ func (m *WithModifiedFieldMutation) Fields() []string

+ func (m *WithModifiedFieldMutation) ID() (id int, exists bool)

+ func (m *WithModifiedFieldMutation) Name() (r string, exists bool)

+ func (m *WithModifiedFieldMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *WithModifiedFieldMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *WithModifiedFieldMutation) Op() Op

+ func (m *WithModifiedFieldMutation) OwnerCleared() bool

+ func (m *WithModifiedFieldMutation) OwnerID() (id int, exists bool)

+ func (m *WithModifiedFieldMutation) OwnerIDs() (ids []int)

+ func (m *WithModifiedFieldMutation) RemovedEdges() []string

+ func (m *WithModifiedFieldMutation) RemovedIDs(name string) []ent.Value

+ func (m *WithModifiedFieldMutation) ResetEdge(name string) error

+ func (m *WithModifiedFieldMutation) ResetField(name string) error

+ func (m *WithModifiedFieldMutation) ResetName()

+ func (m *WithModifiedFieldMutation) ResetOwner()

+ func (m *WithModifiedFieldMutation) SetField(name string, value ent.Value) error

+ func (m *WithModifiedFieldMutation) SetName(s string)

+ func (m *WithModifiedFieldMutation) SetOwnerID(id int)

+ func (m *WithModifiedFieldMutation) Type() string

+ func (m WithModifiedFieldMutation) Client() *Client

+ func (m WithModifiedFieldMutation) Tx() (*Tx, error)

+ type WithModifiedFieldQuery struct

+ func (wmfq *WithModifiedFieldQuery) All(ctx context.Context) ([]*WithModifiedField, error)

+ func (wmfq *WithModifiedFieldQuery) AllX(ctx context.Context) []*WithModifiedField

+ func (wmfq *WithModifiedFieldQuery) Clone() *WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) Count(ctx context.Context) (int, error)

+ func (wmfq *WithModifiedFieldQuery) CountX(ctx context.Context) int

+ func (wmfq *WithModifiedFieldQuery) Exist(ctx context.Context) (bool, error)

+ func (wmfq *WithModifiedFieldQuery) ExistX(ctx context.Context) bool

+ func (wmfq *WithModifiedFieldQuery) First(ctx context.Context) (*WithModifiedField, error)

+ func (wmfq *WithModifiedFieldQuery) FirstID(ctx context.Context) (id int, err error)

+ func (wmfq *WithModifiedFieldQuery) FirstIDX(ctx context.Context) int

+ func (wmfq *WithModifiedFieldQuery) FirstX(ctx context.Context) *WithModifiedField

+ func (wmfq *WithModifiedFieldQuery) GroupBy(field string, fields ...string) *WithModifiedFieldGroupBy

+ func (wmfq *WithModifiedFieldQuery) IDs(ctx context.Context) ([]int, error)

+ func (wmfq *WithModifiedFieldQuery) IDsX(ctx context.Context) []int

+ func (wmfq *WithModifiedFieldQuery) Limit(limit int) *WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) Offset(offset int) *WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) Only(ctx context.Context) (*WithModifiedField, error)

+ func (wmfq *WithModifiedFieldQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (wmfq *WithModifiedFieldQuery) OnlyIDX(ctx context.Context) int

+ func (wmfq *WithModifiedFieldQuery) OnlyX(ctx context.Context) *WithModifiedField

+ func (wmfq *WithModifiedFieldQuery) Order(o ...OrderFunc) *WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) QueryOwner() *UserQuery

+ func (wmfq *WithModifiedFieldQuery) Select(field string, fields ...string) *WithModifiedFieldSelect

+ func (wmfq *WithModifiedFieldQuery) Unique(unique bool) *WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) Where(ps ...predicate.WithModifiedField) *WithModifiedFieldQuery

+ func (wmfq *WithModifiedFieldQuery) WithOwner(opts ...func(*UserQuery)) *WithModifiedFieldQuery

+ type WithModifiedFieldSelect struct

+ func (wmfs *WithModifiedFieldSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (wmfs *WithModifiedFieldSelect) BoolX(ctx context.Context) bool

+ func (wmfs *WithModifiedFieldSelect) Bools(ctx context.Context) ([]bool, error)

+ func (wmfs *WithModifiedFieldSelect) BoolsX(ctx context.Context) []bool

+ func (wmfs *WithModifiedFieldSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (wmfs *WithModifiedFieldSelect) Float64X(ctx context.Context) float64

+ func (wmfs *WithModifiedFieldSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (wmfs *WithModifiedFieldSelect) Float64sX(ctx context.Context) []float64

+ func (wmfs *WithModifiedFieldSelect) Int(ctx context.Context) (_ int, err error)

+ func (wmfs *WithModifiedFieldSelect) IntX(ctx context.Context) int

+ func (wmfs *WithModifiedFieldSelect) Ints(ctx context.Context) ([]int, error)

+ func (wmfs *WithModifiedFieldSelect) IntsX(ctx context.Context) []int

+ func (wmfs *WithModifiedFieldSelect) Scan(ctx context.Context, v interface{}) error

+ func (wmfs *WithModifiedFieldSelect) ScanX(ctx context.Context, v interface{})

+ func (wmfs *WithModifiedFieldSelect) String(ctx context.Context) (_ string, err error)

+ func (wmfs *WithModifiedFieldSelect) StringX(ctx context.Context) string

+ func (wmfs *WithModifiedFieldSelect) Strings(ctx context.Context) ([]string, error)

+ func (wmfs *WithModifiedFieldSelect) StringsX(ctx context.Context) []string

+ type WithModifiedFieldUpdate struct

+ func (wmfu *WithModifiedFieldUpdate) ClearOwner() *WithModifiedFieldUpdate

+ func (wmfu *WithModifiedFieldUpdate) Exec(ctx context.Context) error

+ func (wmfu *WithModifiedFieldUpdate) ExecX(ctx context.Context)

+ func (wmfu *WithModifiedFieldUpdate) Mutation() *WithModifiedFieldMutation

+ func (wmfu *WithModifiedFieldUpdate) Save(ctx context.Context) (int, error)

+ func (wmfu *WithModifiedFieldUpdate) SaveX(ctx context.Context) int

+ func (wmfu *WithModifiedFieldUpdate) SetNillableOwnerID(id *int) *WithModifiedFieldUpdate

+ func (wmfu *WithModifiedFieldUpdate) SetOwner(u *User) *WithModifiedFieldUpdate

+ func (wmfu *WithModifiedFieldUpdate) SetOwnerID(id int) *WithModifiedFieldUpdate

+ func (wmfu *WithModifiedFieldUpdate) Where(ps ...predicate.WithModifiedField) *WithModifiedFieldUpdate

+ type WithModifiedFieldUpdateOne struct

+ func (wmfuo *WithModifiedFieldUpdateOne) ClearOwner() *WithModifiedFieldUpdateOne

+ func (wmfuo *WithModifiedFieldUpdateOne) Exec(ctx context.Context) error

+ func (wmfuo *WithModifiedFieldUpdateOne) ExecX(ctx context.Context)

+ func (wmfuo *WithModifiedFieldUpdateOne) Mutation() *WithModifiedFieldMutation

+ func (wmfuo *WithModifiedFieldUpdateOne) Save(ctx context.Context) (*WithModifiedField, error)

+ func (wmfuo *WithModifiedFieldUpdateOne) SaveX(ctx context.Context) *WithModifiedField

+ func (wmfuo *WithModifiedFieldUpdateOne) Select(field string, fields ...string) *WithModifiedFieldUpdateOne

+ func (wmfuo *WithModifiedFieldUpdateOne) SetNillableOwnerID(id *int) *WithModifiedFieldUpdateOne

+ func (wmfuo *WithModifiedFieldUpdateOne) SetOwner(u *User) *WithModifiedFieldUpdateOne

+ func (wmfuo *WithModifiedFieldUpdateOne) SetOwnerID(id int) *WithModifiedFieldUpdateOne

+ type WithModifiedFields []*WithModifiedField

+ type WithNilFields struct

+ ID int

+ func (wnf *WithNilFields) String() string

+ func (wnf *WithNilFields) Unwrap() *WithNilFields

+ func (wnf *WithNilFields) Update() *WithNilFieldsUpdateOne

+ type WithNilFieldsClient struct

+ func NewWithNilFieldsClient(c config) *WithNilFieldsClient

+ func (c *WithNilFieldsClient) Create() *WithNilFieldsCreate

+ func (c *WithNilFieldsClient) CreateBulk(builders ...*WithNilFieldsCreate) *WithNilFieldsCreateBulk

+ func (c *WithNilFieldsClient) Delete() *WithNilFieldsDelete

+ func (c *WithNilFieldsClient) DeleteOne(wnf *WithNilFields) *WithNilFieldsDeleteOne

+ func (c *WithNilFieldsClient) DeleteOneID(id int) *WithNilFieldsDeleteOne

+ func (c *WithNilFieldsClient) Get(ctx context.Context, id int) (*WithNilFields, error)

+ func (c *WithNilFieldsClient) GetX(ctx context.Context, id int) *WithNilFields

+ func (c *WithNilFieldsClient) Hooks() []Hook

+ func (c *WithNilFieldsClient) Query() *WithNilFieldsQuery

+ func (c *WithNilFieldsClient) Update() *WithNilFieldsUpdate

+ func (c *WithNilFieldsClient) UpdateOne(wnf *WithNilFields) *WithNilFieldsUpdateOne

+ func (c *WithNilFieldsClient) UpdateOneID(id int) *WithNilFieldsUpdateOne

+ func (c *WithNilFieldsClient) Use(hooks ...Hook)

+ type WithNilFieldsCreate struct

+ func (wnfc *WithNilFieldsCreate) Mutation() *WithNilFieldsMutation

+ func (wnfc *WithNilFieldsCreate) Save(ctx context.Context) (*WithNilFields, error)

+ func (wnfc *WithNilFieldsCreate) SaveX(ctx context.Context) *WithNilFields

+ type WithNilFieldsCreateBulk struct

+ func (wnfcb *WithNilFieldsCreateBulk) Save(ctx context.Context) ([]*WithNilFields, error)

+ func (wnfcb *WithNilFieldsCreateBulk) SaveX(ctx context.Context) []*WithNilFields

+ type WithNilFieldsDelete struct

+ func (wnfd *WithNilFieldsDelete) Exec(ctx context.Context) (int, error)

+ func (wnfd *WithNilFieldsDelete) ExecX(ctx context.Context) int

+ func (wnfd *WithNilFieldsDelete) Where(ps ...predicate.WithNilFields) *WithNilFieldsDelete

+ type WithNilFieldsDeleteOne struct

+ func (wnfdo *WithNilFieldsDeleteOne) Exec(ctx context.Context) error

+ func (wnfdo *WithNilFieldsDeleteOne) ExecX(ctx context.Context)

+ type WithNilFieldsGroupBy struct

+ func (wnfgb *WithNilFieldsGroupBy) Aggregate(fns ...AggregateFunc) *WithNilFieldsGroupBy

+ func (wnfgb *WithNilFieldsGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (wnfgb *WithNilFieldsGroupBy) BoolX(ctx context.Context) bool

+ func (wnfgb *WithNilFieldsGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (wnfgb *WithNilFieldsGroupBy) BoolsX(ctx context.Context) []bool

+ func (wnfgb *WithNilFieldsGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (wnfgb *WithNilFieldsGroupBy) Float64X(ctx context.Context) float64

+ func (wnfgb *WithNilFieldsGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (wnfgb *WithNilFieldsGroupBy) Float64sX(ctx context.Context) []float64

+ func (wnfgb *WithNilFieldsGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (wnfgb *WithNilFieldsGroupBy) IntX(ctx context.Context) int

+ func (wnfgb *WithNilFieldsGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (wnfgb *WithNilFieldsGroupBy) IntsX(ctx context.Context) []int

+ func (wnfgb *WithNilFieldsGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (wnfgb *WithNilFieldsGroupBy) ScanX(ctx context.Context, v interface{})

+ func (wnfgb *WithNilFieldsGroupBy) String(ctx context.Context) (_ string, err error)

+ func (wnfgb *WithNilFieldsGroupBy) StringX(ctx context.Context) string

+ func (wnfgb *WithNilFieldsGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (wnfgb *WithNilFieldsGroupBy) StringsX(ctx context.Context) []string

+ type WithNilFieldsMutation struct

+ func (m *WithNilFieldsMutation) AddField(name string, value ent.Value) error

+ func (m *WithNilFieldsMutation) AddedEdges() []string

+ func (m *WithNilFieldsMutation) AddedField(name string) (ent.Value, bool)

+ func (m *WithNilFieldsMutation) AddedFields() []string

+ func (m *WithNilFieldsMutation) AddedIDs(name string) []ent.Value

+ func (m *WithNilFieldsMutation) ClearEdge(name string) error

+ func (m *WithNilFieldsMutation) ClearField(name string) error

+ func (m *WithNilFieldsMutation) ClearedEdges() []string

+ func (m *WithNilFieldsMutation) ClearedFields() []string

+ func (m *WithNilFieldsMutation) EdgeCleared(name string) bool

+ func (m *WithNilFieldsMutation) Field(name string) (ent.Value, bool)

+ func (m *WithNilFieldsMutation) FieldCleared(name string) bool

+ func (m *WithNilFieldsMutation) Fields() []string

+ func (m *WithNilFieldsMutation) ID() (id int, exists bool)

+ func (m *WithNilFieldsMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *WithNilFieldsMutation) Op() Op

+ func (m *WithNilFieldsMutation) RemovedEdges() []string

+ func (m *WithNilFieldsMutation) RemovedIDs(name string) []ent.Value

+ func (m *WithNilFieldsMutation) ResetEdge(name string) error

+ func (m *WithNilFieldsMutation) ResetField(name string) error

+ func (m *WithNilFieldsMutation) SetField(name string, value ent.Value) error

+ func (m *WithNilFieldsMutation) Type() string

+ func (m WithNilFieldsMutation) Client() *Client

+ func (m WithNilFieldsMutation) Tx() (*Tx, error)

+ type WithNilFieldsQuery struct

+ func (wnfq *WithNilFieldsQuery) All(ctx context.Context) ([]*WithNilFields, error)

+ func (wnfq *WithNilFieldsQuery) AllX(ctx context.Context) []*WithNilFields

+ func (wnfq *WithNilFieldsQuery) Clone() *WithNilFieldsQuery

+ func (wnfq *WithNilFieldsQuery) Count(ctx context.Context) (int, error)

+ func (wnfq *WithNilFieldsQuery) CountX(ctx context.Context) int

+ func (wnfq *WithNilFieldsQuery) Exist(ctx context.Context) (bool, error)

+ func (wnfq *WithNilFieldsQuery) ExistX(ctx context.Context) bool

+ func (wnfq *WithNilFieldsQuery) First(ctx context.Context) (*WithNilFields, error)

+ func (wnfq *WithNilFieldsQuery) FirstID(ctx context.Context) (id int, err error)

+ func (wnfq *WithNilFieldsQuery) FirstIDX(ctx context.Context) int

+ func (wnfq *WithNilFieldsQuery) FirstX(ctx context.Context) *WithNilFields

+ func (wnfq *WithNilFieldsQuery) GroupBy(field string, fields ...string) *WithNilFieldsGroupBy

+ func (wnfq *WithNilFieldsQuery) IDs(ctx context.Context) ([]int, error)

+ func (wnfq *WithNilFieldsQuery) IDsX(ctx context.Context) []int

+ func (wnfq *WithNilFieldsQuery) Limit(limit int) *WithNilFieldsQuery

+ func (wnfq *WithNilFieldsQuery) Offset(offset int) *WithNilFieldsQuery

+ func (wnfq *WithNilFieldsQuery) Only(ctx context.Context) (*WithNilFields, error)

+ func (wnfq *WithNilFieldsQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (wnfq *WithNilFieldsQuery) OnlyIDX(ctx context.Context) int

+ func (wnfq *WithNilFieldsQuery) OnlyX(ctx context.Context) *WithNilFields

+ func (wnfq *WithNilFieldsQuery) Order(o ...OrderFunc) *WithNilFieldsQuery

+ func (wnfq *WithNilFieldsQuery) Select(field string, fields ...string) *WithNilFieldsSelect

+ func (wnfq *WithNilFieldsQuery) Unique(unique bool) *WithNilFieldsQuery

+ func (wnfq *WithNilFieldsQuery) Where(ps ...predicate.WithNilFields) *WithNilFieldsQuery

+ type WithNilFieldsSelect struct

+ func (wnfs *WithNilFieldsSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (wnfs *WithNilFieldsSelect) BoolX(ctx context.Context) bool

+ func (wnfs *WithNilFieldsSelect) Bools(ctx context.Context) ([]bool, error)

+ func (wnfs *WithNilFieldsSelect) BoolsX(ctx context.Context) []bool

+ func (wnfs *WithNilFieldsSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (wnfs *WithNilFieldsSelect) Float64X(ctx context.Context) float64

+ func (wnfs *WithNilFieldsSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (wnfs *WithNilFieldsSelect) Float64sX(ctx context.Context) []float64

+ func (wnfs *WithNilFieldsSelect) Int(ctx context.Context) (_ int, err error)

+ func (wnfs *WithNilFieldsSelect) IntX(ctx context.Context) int

+ func (wnfs *WithNilFieldsSelect) Ints(ctx context.Context) ([]int, error)

+ func (wnfs *WithNilFieldsSelect) IntsX(ctx context.Context) []int

+ func (wnfs *WithNilFieldsSelect) Scan(ctx context.Context, v interface{}) error

+ func (wnfs *WithNilFieldsSelect) ScanX(ctx context.Context, v interface{})

+ func (wnfs *WithNilFieldsSelect) String(ctx context.Context) (_ string, err error)

+ func (wnfs *WithNilFieldsSelect) StringX(ctx context.Context) string

+ func (wnfs *WithNilFieldsSelect) Strings(ctx context.Context) ([]string, error)

+ func (wnfs *WithNilFieldsSelect) StringsX(ctx context.Context) []string

+ type WithNilFieldsSlice []*WithNilFields

+ type WithNilFieldsUpdate struct

+ func (wnfu *WithNilFieldsUpdate) Exec(ctx context.Context) error

+ func (wnfu *WithNilFieldsUpdate) ExecX(ctx context.Context)

+ func (wnfu *WithNilFieldsUpdate) Mutation() *WithNilFieldsMutation

+ func (wnfu *WithNilFieldsUpdate) Save(ctx context.Context) (int, error)

+ func (wnfu *WithNilFieldsUpdate) SaveX(ctx context.Context) int

+ func (wnfu *WithNilFieldsUpdate) Where(ps ...predicate.WithNilFields) *WithNilFieldsUpdate

+ type WithNilFieldsUpdateOne struct

+ func (wnfuo *WithNilFieldsUpdateOne) Exec(ctx context.Context) error

+ func (wnfuo *WithNilFieldsUpdateOne) ExecX(ctx context.Context)

+ func (wnfuo *WithNilFieldsUpdateOne) Mutation() *WithNilFieldsMutation

+ func (wnfuo *WithNilFieldsUpdateOne) Save(ctx context.Context) (*WithNilFields, error)

+ func (wnfuo *WithNilFieldsUpdateOne) SaveX(ctx context.Context) *WithNilFields

+ func (wnfuo *WithNilFieldsUpdateOne) Select(field string, fields ...string) *WithNilFieldsUpdateOne

+ type WithoutFields struct

+ ID int

+ func (wf *WithoutFields) String() string

+ func (wf *WithoutFields) Unwrap() *WithoutFields

+ func (wf *WithoutFields) Update() *WithoutFieldsUpdateOne

+ type WithoutFieldsClient struct

+ func NewWithoutFieldsClient(c config) *WithoutFieldsClient

+ func (c *WithoutFieldsClient) Create() *WithoutFieldsCreate

+ func (c *WithoutFieldsClient) CreateBulk(builders ...*WithoutFieldsCreate) *WithoutFieldsCreateBulk

+ func (c *WithoutFieldsClient) Delete() *WithoutFieldsDelete

+ func (c *WithoutFieldsClient) DeleteOne(wf *WithoutFields) *WithoutFieldsDeleteOne

+ func (c *WithoutFieldsClient) DeleteOneID(id int) *WithoutFieldsDeleteOne

+ func (c *WithoutFieldsClient) Get(ctx context.Context, id int) (*WithoutFields, error)

+ func (c *WithoutFieldsClient) GetX(ctx context.Context, id int) *WithoutFields

+ func (c *WithoutFieldsClient) Hooks() []Hook

+ func (c *WithoutFieldsClient) Query() *WithoutFieldsQuery

+ func (c *WithoutFieldsClient) Update() *WithoutFieldsUpdate

+ func (c *WithoutFieldsClient) UpdateOne(wf *WithoutFields) *WithoutFieldsUpdateOne

+ func (c *WithoutFieldsClient) UpdateOneID(id int) *WithoutFieldsUpdateOne

+ func (c *WithoutFieldsClient) Use(hooks ...Hook)

+ type WithoutFieldsCreate struct

+ func (wfc *WithoutFieldsCreate) Mutation() *WithoutFieldsMutation

+ func (wfc *WithoutFieldsCreate) Save(ctx context.Context) (*WithoutFields, error)

+ func (wfc *WithoutFieldsCreate) SaveX(ctx context.Context) *WithoutFields

+ type WithoutFieldsCreateBulk struct

+ func (wfcb *WithoutFieldsCreateBulk) Save(ctx context.Context) ([]*WithoutFields, error)

+ func (wfcb *WithoutFieldsCreateBulk) SaveX(ctx context.Context) []*WithoutFields

+ type WithoutFieldsDelete struct

+ func (wfd *WithoutFieldsDelete) Exec(ctx context.Context) (int, error)

+ func (wfd *WithoutFieldsDelete) ExecX(ctx context.Context) int

+ func (wfd *WithoutFieldsDelete) Where(ps ...predicate.WithoutFields) *WithoutFieldsDelete

+ type WithoutFieldsDeleteOne struct

+ func (wfdo *WithoutFieldsDeleteOne) Exec(ctx context.Context) error

+ func (wfdo *WithoutFieldsDeleteOne) ExecX(ctx context.Context)

+ type WithoutFieldsGroupBy struct

+ func (wfgb *WithoutFieldsGroupBy) Aggregate(fns ...AggregateFunc) *WithoutFieldsGroupBy

+ func (wfgb *WithoutFieldsGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (wfgb *WithoutFieldsGroupBy) BoolX(ctx context.Context) bool

+ func (wfgb *WithoutFieldsGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (wfgb *WithoutFieldsGroupBy) BoolsX(ctx context.Context) []bool

+ func (wfgb *WithoutFieldsGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (wfgb *WithoutFieldsGroupBy) Float64X(ctx context.Context) float64

+ func (wfgb *WithoutFieldsGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (wfgb *WithoutFieldsGroupBy) Float64sX(ctx context.Context) []float64

+ func (wfgb *WithoutFieldsGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (wfgb *WithoutFieldsGroupBy) IntX(ctx context.Context) int

+ func (wfgb *WithoutFieldsGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (wfgb *WithoutFieldsGroupBy) IntsX(ctx context.Context) []int

+ func (wfgb *WithoutFieldsGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (wfgb *WithoutFieldsGroupBy) ScanX(ctx context.Context, v interface{})

+ func (wfgb *WithoutFieldsGroupBy) String(ctx context.Context) (_ string, err error)

+ func (wfgb *WithoutFieldsGroupBy) StringX(ctx context.Context) string

+ func (wfgb *WithoutFieldsGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (wfgb *WithoutFieldsGroupBy) StringsX(ctx context.Context) []string

+ type WithoutFieldsMutation struct

+ func (m *WithoutFieldsMutation) AddField(name string, value ent.Value) error

+ func (m *WithoutFieldsMutation) AddedEdges() []string

+ func (m *WithoutFieldsMutation) AddedField(name string) (ent.Value, bool)

+ func (m *WithoutFieldsMutation) AddedFields() []string

+ func (m *WithoutFieldsMutation) AddedIDs(name string) []ent.Value

+ func (m *WithoutFieldsMutation) ClearEdge(name string) error

+ func (m *WithoutFieldsMutation) ClearField(name string) error

+ func (m *WithoutFieldsMutation) ClearedEdges() []string

+ func (m *WithoutFieldsMutation) ClearedFields() []string

+ func (m *WithoutFieldsMutation) EdgeCleared(name string) bool

+ func (m *WithoutFieldsMutation) Field(name string) (ent.Value, bool)

+ func (m *WithoutFieldsMutation) FieldCleared(name string) bool

+ func (m *WithoutFieldsMutation) Fields() []string

+ func (m *WithoutFieldsMutation) ID() (id int, exists bool)

+ func (m *WithoutFieldsMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *WithoutFieldsMutation) Op() Op

+ func (m *WithoutFieldsMutation) RemovedEdges() []string

+ func (m *WithoutFieldsMutation) RemovedIDs(name string) []ent.Value

+ func (m *WithoutFieldsMutation) ResetEdge(name string) error

+ func (m *WithoutFieldsMutation) ResetField(name string) error

+ func (m *WithoutFieldsMutation) SetField(name string, value ent.Value) error

+ func (m *WithoutFieldsMutation) Type() string

+ func (m WithoutFieldsMutation) Client() *Client

+ func (m WithoutFieldsMutation) Tx() (*Tx, error)

+ type WithoutFieldsQuery struct

+ func (wfq *WithoutFieldsQuery) All(ctx context.Context) ([]*WithoutFields, error)

+ func (wfq *WithoutFieldsQuery) AllX(ctx context.Context) []*WithoutFields

+ func (wfq *WithoutFieldsQuery) Clone() *WithoutFieldsQuery

+ func (wfq *WithoutFieldsQuery) Count(ctx context.Context) (int, error)

+ func (wfq *WithoutFieldsQuery) CountX(ctx context.Context) int

+ func (wfq *WithoutFieldsQuery) Exist(ctx context.Context) (bool, error)

+ func (wfq *WithoutFieldsQuery) ExistX(ctx context.Context) bool

+ func (wfq *WithoutFieldsQuery) First(ctx context.Context) (*WithoutFields, error)

+ func (wfq *WithoutFieldsQuery) FirstID(ctx context.Context) (id int, err error)

+ func (wfq *WithoutFieldsQuery) FirstIDX(ctx context.Context) int

+ func (wfq *WithoutFieldsQuery) FirstX(ctx context.Context) *WithoutFields

+ func (wfq *WithoutFieldsQuery) GroupBy(field string, fields ...string) *WithoutFieldsGroupBy

+ func (wfq *WithoutFieldsQuery) IDs(ctx context.Context) ([]int, error)

+ func (wfq *WithoutFieldsQuery) IDsX(ctx context.Context) []int

+ func (wfq *WithoutFieldsQuery) Limit(limit int) *WithoutFieldsQuery

+ func (wfq *WithoutFieldsQuery) Offset(offset int) *WithoutFieldsQuery

+ func (wfq *WithoutFieldsQuery) Only(ctx context.Context) (*WithoutFields, error)

+ func (wfq *WithoutFieldsQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (wfq *WithoutFieldsQuery) OnlyIDX(ctx context.Context) int

+ func (wfq *WithoutFieldsQuery) OnlyX(ctx context.Context) *WithoutFields

+ func (wfq *WithoutFieldsQuery) Order(o ...OrderFunc) *WithoutFieldsQuery

+ func (wfq *WithoutFieldsQuery) Select(field string, fields ...string) *WithoutFieldsSelect

+ func (wfq *WithoutFieldsQuery) Unique(unique bool) *WithoutFieldsQuery

+ func (wfq *WithoutFieldsQuery) Where(ps ...predicate.WithoutFields) *WithoutFieldsQuery

+ type WithoutFieldsSelect struct

+ func (wfs *WithoutFieldsSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (wfs *WithoutFieldsSelect) BoolX(ctx context.Context) bool

+ func (wfs *WithoutFieldsSelect) Bools(ctx context.Context) ([]bool, error)

+ func (wfs *WithoutFieldsSelect) BoolsX(ctx context.Context) []bool

+ func (wfs *WithoutFieldsSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (wfs *WithoutFieldsSelect) Float64X(ctx context.Context) float64

+ func (wfs *WithoutFieldsSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (wfs *WithoutFieldsSelect) Float64sX(ctx context.Context) []float64

+ func (wfs *WithoutFieldsSelect) Int(ctx context.Context) (_ int, err error)

+ func (wfs *WithoutFieldsSelect) IntX(ctx context.Context) int

+ func (wfs *WithoutFieldsSelect) Ints(ctx context.Context) ([]int, error)

+ func (wfs *WithoutFieldsSelect) IntsX(ctx context.Context) []int

+ func (wfs *WithoutFieldsSelect) Scan(ctx context.Context, v interface{}) error

+ func (wfs *WithoutFieldsSelect) ScanX(ctx context.Context, v interface{})

+ func (wfs *WithoutFieldsSelect) String(ctx context.Context) (_ string, err error)

+ func (wfs *WithoutFieldsSelect) StringX(ctx context.Context) string

+ func (wfs *WithoutFieldsSelect) Strings(ctx context.Context) ([]string, error)

+ func (wfs *WithoutFieldsSelect) StringsX(ctx context.Context) []string

+ type WithoutFieldsSlice []*WithoutFields

+ type WithoutFieldsUpdate struct

+ func (wfu *WithoutFieldsUpdate) Exec(ctx context.Context) error

+ func (wfu *WithoutFieldsUpdate) ExecX(ctx context.Context)

+ func (wfu *WithoutFieldsUpdate) Mutation() *WithoutFieldsMutation

+ func (wfu *WithoutFieldsUpdate) Save(ctx context.Context) (int, error)

+ func (wfu *WithoutFieldsUpdate) SaveX(ctx context.Context) int

+ func (wfu *WithoutFieldsUpdate) Where(ps ...predicate.WithoutFields) *WithoutFieldsUpdate

+ type WithoutFieldsUpdateOne struct

+ func (wfuo *WithoutFieldsUpdateOne) Exec(ctx context.Context) error

+ func (wfuo *WithoutFieldsUpdateOne) ExecX(ctx context.Context)

+ func (wfuo *WithoutFieldsUpdateOne) Mutation() *WithoutFieldsMutation

+ func (wfuo *WithoutFieldsUpdateOne) Save(ctx context.Context) (*WithoutFields, error)

+ func (wfuo *WithoutFieldsUpdateOne) SaveX(ctx context.Context) *WithoutFields

+ func (wfuo *WithoutFieldsUpdateOne) Select(field string, fields ...string) *WithoutFieldsUpdateOne

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL