query

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IDeleteQueueDo
• type IFileDo
• type IMasterAccountDo
• type IRedeemCodeDo
• type ISharedLinkDo
• type ITokenDo
• type IUserDo
• type IWorkerAccountDo
• type Query
  • func Use(db *gorm.DB, opts ...gen.DOOption) *Query
  • func (q *Query) Available() bool
  • func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx
  • func (q *Query) ReadDB() *Query
  • func (q *Query) ReplaceDB(db *gorm.DB) *Query
  • func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error
  • func (q *Query) WithContext(ctx context.Context) *queryCtx
  • func (q *Query) WriteDB() *Query
• type QueryTx
  • func (q *QueryTx) Commit() error
  • func (q *QueryTx) Rollback() error
  • func (q *QueryTx) RollbackTo(name string) error
  • func (q *QueryTx) SavePoint(name string) error

Variables

var (
	Q             = new(Query)
	DeleteQueue   *deleteQueue
	File          *file
	MasterAccount *masterAccount
	RedeemCode    *redeemCode
	SharedLink    *sharedLink
	Token         *token
	WorkerAccount *workerAccount
)

Functions

func SetDefault

func SetDefault(db *gorm.DB, opts ...gen.DOOption)

Types

type IDeleteQueueDo

type IDeleteQueueDo interface {
	gen.SubQuery
	Debug() IDeleteQueueDo
	WithContext(ctx context.Context) IDeleteQueueDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IDeleteQueueDo
	WriteDB() IDeleteQueueDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IDeleteQueueDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IDeleteQueueDo
	Not(conds ...gen.Condition) IDeleteQueueDo
	Or(conds ...gen.Condition) IDeleteQueueDo
	Select(conds ...field.Expr) IDeleteQueueDo
	Where(conds ...gen.Condition) IDeleteQueueDo
	Order(conds ...field.Expr) IDeleteQueueDo
	Distinct(cols ...field.Expr) IDeleteQueueDo
	Omit(cols ...field.Expr) IDeleteQueueDo
	Join(table schema.Tabler, on ...field.Expr) IDeleteQueueDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IDeleteQueueDo
	RightJoin(table schema.Tabler, on ...field.Expr) IDeleteQueueDo
	Group(cols ...field.Expr) IDeleteQueueDo
	Having(conds ...gen.Condition) IDeleteQueueDo
	Limit(limit int) IDeleteQueueDo
	Offset(offset int) IDeleteQueueDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IDeleteQueueDo
	Unscoped() IDeleteQueueDo
	Create(values ...*model.DeleteQueue) error
	CreateInBatches(values []*model.DeleteQueue, batchSize int) error
	Save(values ...*model.DeleteQueue) error
	First() (*model.DeleteQueue, error)
	Take() (*model.DeleteQueue, error)
	Last() (*model.DeleteQueue, error)
	Find() ([]*model.DeleteQueue, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DeleteQueue, err error)
	FindInBatches(result *[]*model.DeleteQueue, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.DeleteQueue) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IDeleteQueueDo
	Assign(attrs ...field.AssignExpr) IDeleteQueueDo
	Joins(fields ...field.RelationField) IDeleteQueueDo
	Preload(fields ...field.RelationField) IDeleteQueueDo
	FirstOrInit() (*model.DeleteQueue, error)
	FirstOrCreate() (*model.DeleteQueue, error)
	FindByPage(offset int, limit int) (result []*model.DeleteQueue, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IDeleteQueueDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IFileDo

type IFileDo interface {
	gen.SubQuery
	Debug() IFileDo
	WithContext(ctx context.Context) IFileDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IFileDo
	WriteDB() IFileDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IFileDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IFileDo
	Not(conds ...gen.Condition) IFileDo
	Or(conds ...gen.Condition) IFileDo
	Select(conds ...field.Expr) IFileDo
	Where(conds ...gen.Condition) IFileDo
	Order(conds ...field.Expr) IFileDo
	Distinct(cols ...field.Expr) IFileDo
	Omit(cols ...field.Expr) IFileDo
	Join(table schema.Tabler, on ...field.Expr) IFileDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IFileDo
	RightJoin(table schema.Tabler, on ...field.Expr) IFileDo
	Group(cols ...field.Expr) IFileDo
	Having(conds ...gen.Condition) IFileDo
	Limit(limit int) IFileDo
	Offset(offset int) IFileDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IFileDo
	Unscoped() IFileDo
	Create(values ...*model.File) error
	CreateInBatches(values []*model.File, batchSize int) error
	Save(values ...*model.File) error
	First() (*model.File, error)
	Take() (*model.File, error)
	Last() (*model.File, error)
	Find() ([]*model.File, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.File, err error)
	FindInBatches(result *[]*model.File, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.File) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IFileDo
	Assign(attrs ...field.AssignExpr) IFileDo
	Joins(fields ...field.RelationField) IFileDo
	Preload(fields ...field.RelationField) IFileDo
	FirstOrInit() (*model.File, error)
	FirstOrCreate() (*model.File, error)
	FindByPage(offset int, limit int) (result []*model.File, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IFileDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IMasterAccountDo

type IMasterAccountDo interface {
	gen.SubQuery
	Debug() IMasterAccountDo
	WithContext(ctx context.Context) IMasterAccountDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IMasterAccountDo
	WriteDB() IMasterAccountDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IMasterAccountDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IMasterAccountDo
	Not(conds ...gen.Condition) IMasterAccountDo
	Or(conds ...gen.Condition) IMasterAccountDo
	Select(conds ...field.Expr) IMasterAccountDo
	Where(conds ...gen.Condition) IMasterAccountDo
	Order(conds ...field.Expr) IMasterAccountDo
	Distinct(cols ...field.Expr) IMasterAccountDo
	Omit(cols ...field.Expr) IMasterAccountDo
	Join(table schema.Tabler, on ...field.Expr) IMasterAccountDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IMasterAccountDo
	RightJoin(table schema.Tabler, on ...field.Expr) IMasterAccountDo
	Group(cols ...field.Expr) IMasterAccountDo
	Having(conds ...gen.Condition) IMasterAccountDo
	Limit(limit int) IMasterAccountDo
	Offset(offset int) IMasterAccountDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IMasterAccountDo
	Unscoped() IMasterAccountDo
	Create(values ...*model.MasterAccount) error
	CreateInBatches(values []*model.MasterAccount, batchSize int) error
	Save(values ...*model.MasterAccount) error
	First() (*model.MasterAccount, error)
	Take() (*model.MasterAccount, error)
	Last() (*model.MasterAccount, error)
	Find() ([]*model.MasterAccount, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.MasterAccount, err error)
	FindInBatches(result *[]*model.MasterAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.MasterAccount) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IMasterAccountDo
	Assign(attrs ...field.AssignExpr) IMasterAccountDo
	Joins(fields ...field.RelationField) IMasterAccountDo
	Preload(fields ...field.RelationField) IMasterAccountDo
	FirstOrInit() (*model.MasterAccount, error)
	FirstOrCreate() (*model.MasterAccount, error)
	FindByPage(offset int, limit int) (result []*model.MasterAccount, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IMasterAccountDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IRedeemCodeDo

type IRedeemCodeDo interface {
	gen.SubQuery
	Debug() IRedeemCodeDo
	WithContext(ctx context.Context) IRedeemCodeDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IRedeemCodeDo
	WriteDB() IRedeemCodeDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IRedeemCodeDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IRedeemCodeDo
	Not(conds ...gen.Condition) IRedeemCodeDo
	Or(conds ...gen.Condition) IRedeemCodeDo
	Select(conds ...field.Expr) IRedeemCodeDo
	Where(conds ...gen.Condition) IRedeemCodeDo
	Order(conds ...field.Expr) IRedeemCodeDo
	Distinct(cols ...field.Expr) IRedeemCodeDo
	Omit(cols ...field.Expr) IRedeemCodeDo
	Join(table schema.Tabler, on ...field.Expr) IRedeemCodeDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IRedeemCodeDo
	RightJoin(table schema.Tabler, on ...field.Expr) IRedeemCodeDo
	Group(cols ...field.Expr) IRedeemCodeDo
	Having(conds ...gen.Condition) IRedeemCodeDo
	Limit(limit int) IRedeemCodeDo
	Offset(offset int) IRedeemCodeDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IRedeemCodeDo
	Unscoped() IRedeemCodeDo
	Create(values ...*model.RedeemCode) error
	CreateInBatches(values []*model.RedeemCode, batchSize int) error
	Save(values ...*model.RedeemCode) error
	First() (*model.RedeemCode, error)
	Take() (*model.RedeemCode, error)
	Last() (*model.RedeemCode, error)
	Find() ([]*model.RedeemCode, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.RedeemCode, err error)
	FindInBatches(result *[]*model.RedeemCode, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.RedeemCode) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IRedeemCodeDo
	Assign(attrs ...field.AssignExpr) IRedeemCodeDo
	Joins(fields ...field.RelationField) IRedeemCodeDo
	Preload(fields ...field.RelationField) IRedeemCodeDo
	FirstOrInit() (*model.RedeemCode, error)
	FirstOrCreate() (*model.RedeemCode, error)
	FindByPage(offset int, limit int) (result []*model.RedeemCode, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IRedeemCodeDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ISharedLinkDo

type ISharedLinkDo interface {
	gen.SubQuery
	Debug() ISharedLinkDo
	WithContext(ctx context.Context) ISharedLinkDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ISharedLinkDo
	WriteDB() ISharedLinkDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ISharedLinkDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ISharedLinkDo
	Not(conds ...gen.Condition) ISharedLinkDo
	Or(conds ...gen.Condition) ISharedLinkDo
	Select(conds ...field.Expr) ISharedLinkDo
	Where(conds ...gen.Condition) ISharedLinkDo
	Order(conds ...field.Expr) ISharedLinkDo
	Distinct(cols ...field.Expr) ISharedLinkDo
	Omit(cols ...field.Expr) ISharedLinkDo
	Join(table schema.Tabler, on ...field.Expr) ISharedLinkDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ISharedLinkDo
	RightJoin(table schema.Tabler, on ...field.Expr) ISharedLinkDo
	Group(cols ...field.Expr) ISharedLinkDo
	Having(conds ...gen.Condition) ISharedLinkDo
	Limit(limit int) ISharedLinkDo
	Offset(offset int) ISharedLinkDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ISharedLinkDo
	Unscoped() ISharedLinkDo
	Create(values ...*model.SharedLink) error
	CreateInBatches(values []*model.SharedLink, batchSize int) error
	Save(values ...*model.SharedLink) error
	First() (*model.SharedLink, error)
	Take() (*model.SharedLink, error)
	Last() (*model.SharedLink, error)
	Find() ([]*model.SharedLink, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.SharedLink, err error)
	FindInBatches(result *[]*model.SharedLink, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.SharedLink) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) ISharedLinkDo
	Assign(attrs ...field.AssignExpr) ISharedLinkDo
	Joins(fields ...field.RelationField) ISharedLinkDo
	Preload(fields ...field.RelationField) ISharedLinkDo
	FirstOrInit() (*model.SharedLink, error)
	FirstOrCreate() (*model.SharedLink, error)
	FindByPage(offset int, limit int) (result []*model.SharedLink, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) ISharedLinkDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ITokenDo

type ITokenDo interface {
	gen.SubQuery
	Debug() ITokenDo
	WithContext(ctx context.Context) ITokenDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ITokenDo
	WriteDB() ITokenDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ITokenDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ITokenDo
	Not(conds ...gen.Condition) ITokenDo
	Or(conds ...gen.Condition) ITokenDo
	Select(conds ...field.Expr) ITokenDo
	Where(conds ...gen.Condition) ITokenDo
	Order(conds ...field.Expr) ITokenDo
	Distinct(cols ...field.Expr) ITokenDo
	Omit(cols ...field.Expr) ITokenDo
	Join(table schema.Tabler, on ...field.Expr) ITokenDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ITokenDo
	RightJoin(table schema.Tabler, on ...field.Expr) ITokenDo
	Group(cols ...field.Expr) ITokenDo
	Having(conds ...gen.Condition) ITokenDo
	Limit(limit int) ITokenDo
	Offset(offset int) ITokenDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ITokenDo
	Unscoped() ITokenDo
	Create(values ...*model.Token) error
	CreateInBatches(values []*model.Token, batchSize int) error
	Save(values ...*model.Token) error
	First() (*model.Token, error)
	Take() (*model.Token, error)
	Last() (*model.Token, error)
	Find() ([]*model.Token, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Token, err error)
	FindInBatches(result *[]*model.Token, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Token) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) ITokenDo
	Assign(attrs ...field.AssignExpr) ITokenDo
	Joins(fields ...field.RelationField) ITokenDo
	Preload(fields ...field.RelationField) ITokenDo
	FirstOrInit() (*model.Token, error)
	FirstOrCreate() (*model.Token, error)
	FindByPage(offset int, limit int) (result []*model.Token, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) ITokenDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IUserDo

type IUserDo interface {
	gen.SubQuery
	Debug() IUserDo
	WithContext(ctx context.Context) IUserDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserDo
	WriteDB() IUserDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserDo
	Not(conds ...gen.Condition) IUserDo
	Or(conds ...gen.Condition) IUserDo
	Select(conds ...field.Expr) IUserDo
	Where(conds ...gen.Condition) IUserDo
	Order(conds ...field.Expr) IUserDo
	Distinct(cols ...field.Expr) IUserDo
	Omit(cols ...field.Expr) IUserDo
	Join(table schema.Tabler, on ...field.Expr) IUserDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserDo
	Group(cols ...field.Expr) IUserDo
	Having(conds ...gen.Condition) IUserDo
	Limit(limit int) IUserDo
	Offset(offset int) IUserDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo
	Unscoped() IUserDo
	Create(values ...*model.User) error
	CreateInBatches(values []*model.User, batchSize int) error
	Save(values ...*model.User) error
	First() (*model.User, error)
	Take() (*model.User, error)
	Last() (*model.User, error)
	Find() ([]*model.User, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error)
	FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.User) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IUserDo
	Assign(attrs ...field.AssignExpr) IUserDo
	Joins(fields ...field.RelationField) IUserDo
	Preload(fields ...field.RelationField) IUserDo
	FirstOrInit() (*model.User, error)
	FirstOrCreate() (*model.User, error)
	FindByPage(offset int, limit int) (result []*model.User, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IUserDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IWorkerAccountDo

type IWorkerAccountDo interface {
	gen.SubQuery
	Debug() IWorkerAccountDo
	WithContext(ctx context.Context) IWorkerAccountDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IWorkerAccountDo
	WriteDB() IWorkerAccountDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IWorkerAccountDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IWorkerAccountDo
	Not(conds ...gen.Condition) IWorkerAccountDo
	Or(conds ...gen.Condition) IWorkerAccountDo
	Select(conds ...field.Expr) IWorkerAccountDo
	Where(conds ...gen.Condition) IWorkerAccountDo
	Order(conds ...field.Expr) IWorkerAccountDo
	Distinct(cols ...field.Expr) IWorkerAccountDo
	Omit(cols ...field.Expr) IWorkerAccountDo
	Join(table schema.Tabler, on ...field.Expr) IWorkerAccountDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IWorkerAccountDo
	RightJoin(table schema.Tabler, on ...field.Expr) IWorkerAccountDo
	Group(cols ...field.Expr) IWorkerAccountDo
	Having(conds ...gen.Condition) IWorkerAccountDo
	Limit(limit int) IWorkerAccountDo
	Offset(offset int) IWorkerAccountDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IWorkerAccountDo
	Unscoped() IWorkerAccountDo
	Create(values ...*model.WorkerAccount) error
	CreateInBatches(values []*model.WorkerAccount, batchSize int) error
	Save(values ...*model.WorkerAccount) error
	First() (*model.WorkerAccount, error)
	Take() (*model.WorkerAccount, error)
	Last() (*model.WorkerAccount, error)
	Find() ([]*model.WorkerAccount, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.WorkerAccount, err error)
	FindInBatches(result *[]*model.WorkerAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.WorkerAccount) (info gen.ResultInfo, err error)
	Update(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	Updates(value interface{}) (info gen.ResultInfo, err error)
	UpdateColumn(column field.Expr, value interface{}) (info gen.ResultInfo, err error)
	UpdateColumnSimple(columns ...field.AssignExpr) (info gen.ResultInfo, err error)
	UpdateColumns(value interface{}) (info gen.ResultInfo, err error)
	UpdateFrom(q gen.SubQuery) gen.Dao
	Attrs(attrs ...field.AssignExpr) IWorkerAccountDo
	Assign(attrs ...field.AssignExpr) IWorkerAccountDo
	Joins(fields ...field.RelationField) IWorkerAccountDo
	Preload(fields ...field.RelationField) IWorkerAccountDo
	FirstOrInit() (*model.WorkerAccount, error)
	FirstOrCreate() (*model.WorkerAccount, error)
	FindByPage(offset int, limit int) (result []*model.WorkerAccount, count int64, err error)
	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
	Scan(result interface{}) (err error)
	Returning(value interface{}, columns ...string) IWorkerAccountDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type Query

type Query struct {
	DeleteQueue   deleteQueue
	File          file
	MasterAccount masterAccount
	RedeemCode    redeemCode
	SharedLink    sharedLink
	Token         token
	WorkerAccount workerAccount
	// contains filtered or unexported fields
}

func Use

func Use(db *gorm.DB, opts ...gen.DOOption) *Query

func (*Query) Available

func (q *Query) Available() bool

func (*Query) Begin

func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx

func (*Query) ReadDB

func (q *Query) ReadDB() *Query

func (*Query) ReplaceDB

func (q *Query) ReplaceDB(db *gorm.DB) *Query

func (*Query) Transaction

func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error

func (*Query) WithContext

func (q *Query) WithContext(ctx context.Context) *queryCtx

func (*Query) WriteDB

func (q *Query) WriteDB() *Query

type QueryTx

type QueryTx struct {
	*Query
	Error error
}

func (*QueryTx) Commit

func (q *QueryTx) Commit() error

func (*QueryTx) Rollback

func (q *QueryTx) Rollback() error

func (*QueryTx) RollbackTo

func (q *QueryTx) RollbackTo(name string) error

func (*QueryTx) SavePoint

func (q *QueryTx) SavePoint(name string) error