dao

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IAccountConnectDo
• type IAccountDo
• type IAgreementDo
• type IAgreementVersionDo
• type IConfigDo
• type IGithubAccountDo
• type ISessionKeyDo
• type IUserDo
• type IUserSignatureDo
• type IVerifyCodeDo
• 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)
	Account          *account
	AccountConnect   *accountConnect
	Agreement        *agreement
	AgreementVersion *agreementVersion
	Config           *config
	GithubAccount    *githubAccount
	SessionKey       *sessionKey
	User             *user
	UserSignature    *userSignature
	VerifyCode       *verifyCode
)

Functions

func SetDefault

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

Types

type IAccountConnectDo

type IAccountConnectDo interface {
	gen.SubQuery
	Debug() IAccountConnectDo
	WithContext(ctx context.Context) IAccountConnectDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAccountConnectDo
	WriteDB() IAccountConnectDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAccountConnectDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAccountConnectDo
	Not(conds ...gen.Condition) IAccountConnectDo
	Or(conds ...gen.Condition) IAccountConnectDo
	Select(conds ...field.Expr) IAccountConnectDo
	Where(conds ...gen.Condition) IAccountConnectDo
	Order(conds ...field.Expr) IAccountConnectDo
	Distinct(cols ...field.Expr) IAccountConnectDo
	Omit(cols ...field.Expr) IAccountConnectDo
	Join(table schema.Tabler, on ...field.Expr) IAccountConnectDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAccountConnectDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAccountConnectDo
	Group(cols ...field.Expr) IAccountConnectDo
	Having(conds ...gen.Condition) IAccountConnectDo
	Limit(limit int) IAccountConnectDo
	Offset(offset int) IAccountConnectDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAccountConnectDo
	Unscoped() IAccountConnectDo
	Create(values ...*model.AccountConnect) error
	CreateInBatches(values []*model.AccountConnect, batchSize int) error
	Save(values ...*model.AccountConnect) error
	First() (*model.AccountConnect, error)
	Take() (*model.AccountConnect, error)
	Last() (*model.AccountConnect, error)
	Find() ([]*model.AccountConnect, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AccountConnect, err error)
	FindInBatches(result *[]*model.AccountConnect, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AccountConnect) (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) IAccountConnectDo
	Assign(attrs ...field.AssignExpr) IAccountConnectDo
	Joins(fields ...field.RelationField) IAccountConnectDo
	Preload(fields ...field.RelationField) IAccountConnectDo
	FirstOrInit() (*model.AccountConnect, error)
	FirstOrCreate() (*model.AccountConnect, error)
	FindByPage(offset int, limit int) (result []*model.AccountConnect, 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) IAccountConnectDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAccountDo

type IAccountDo interface {
	gen.SubQuery
	Debug() IAccountDo
	WithContext(ctx context.Context) IAccountDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAccountDo
	WriteDB() IAccountDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAccountDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAccountDo
	Not(conds ...gen.Condition) IAccountDo
	Or(conds ...gen.Condition) IAccountDo
	Select(conds ...field.Expr) IAccountDo
	Where(conds ...gen.Condition) IAccountDo
	Order(conds ...field.Expr) IAccountDo
	Distinct(cols ...field.Expr) IAccountDo
	Omit(cols ...field.Expr) IAccountDo
	Join(table schema.Tabler, on ...field.Expr) IAccountDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAccountDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAccountDo
	Group(cols ...field.Expr) IAccountDo
	Having(conds ...gen.Condition) IAccountDo
	Limit(limit int) IAccountDo
	Offset(offset int) IAccountDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAccountDo
	Unscoped() IAccountDo
	Create(values ...*model.Account) error
	CreateInBatches(values []*model.Account, batchSize int) error
	Save(values ...*model.Account) error
	First() (*model.Account, error)
	Take() (*model.Account, error)
	Last() (*model.Account, error)
	Find() ([]*model.Account, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Account, err error)
	FindInBatches(result *[]*model.Account, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Account) (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) IAccountDo
	Assign(attrs ...field.AssignExpr) IAccountDo
	Joins(fields ...field.RelationField) IAccountDo
	Preload(fields ...field.RelationField) IAccountDo
	FirstOrInit() (*model.Account, error)
	FirstOrCreate() (*model.Account, error)
	FindByPage(offset int, limit int) (result []*model.Account, 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) IAccountDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAgreementDo

type IAgreementDo interface {
	gen.SubQuery
	Debug() IAgreementDo
	WithContext(ctx context.Context) IAgreementDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAgreementDo
	WriteDB() IAgreementDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAgreementDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAgreementDo
	Not(conds ...gen.Condition) IAgreementDo
	Or(conds ...gen.Condition) IAgreementDo
	Select(conds ...field.Expr) IAgreementDo
	Where(conds ...gen.Condition) IAgreementDo
	Order(conds ...field.Expr) IAgreementDo
	Distinct(cols ...field.Expr) IAgreementDo
	Omit(cols ...field.Expr) IAgreementDo
	Join(table schema.Tabler, on ...field.Expr) IAgreementDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAgreementDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAgreementDo
	Group(cols ...field.Expr) IAgreementDo
	Having(conds ...gen.Condition) IAgreementDo
	Limit(limit int) IAgreementDo
	Offset(offset int) IAgreementDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAgreementDo
	Unscoped() IAgreementDo
	Create(values ...*model.Agreement) error
	CreateInBatches(values []*model.Agreement, batchSize int) error
	Save(values ...*model.Agreement) error
	First() (*model.Agreement, error)
	Take() (*model.Agreement, error)
	Last() (*model.Agreement, error)
	Find() ([]*model.Agreement, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Agreement, err error)
	FindInBatches(result *[]*model.Agreement, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Agreement) (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) IAgreementDo
	Assign(attrs ...field.AssignExpr) IAgreementDo
	Joins(fields ...field.RelationField) IAgreementDo
	Preload(fields ...field.RelationField) IAgreementDo
	FirstOrInit() (*model.Agreement, error)
	FirstOrCreate() (*model.Agreement, error)
	FindByPage(offset int, limit int) (result []*model.Agreement, 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) IAgreementDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IAgreementVersionDo

type IAgreementVersionDo interface {
	gen.SubQuery
	Debug() IAgreementVersionDo
	WithContext(ctx context.Context) IAgreementVersionDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IAgreementVersionDo
	WriteDB() IAgreementVersionDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IAgreementVersionDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IAgreementVersionDo
	Not(conds ...gen.Condition) IAgreementVersionDo
	Or(conds ...gen.Condition) IAgreementVersionDo
	Select(conds ...field.Expr) IAgreementVersionDo
	Where(conds ...gen.Condition) IAgreementVersionDo
	Order(conds ...field.Expr) IAgreementVersionDo
	Distinct(cols ...field.Expr) IAgreementVersionDo
	Omit(cols ...field.Expr) IAgreementVersionDo
	Join(table schema.Tabler, on ...field.Expr) IAgreementVersionDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IAgreementVersionDo
	RightJoin(table schema.Tabler, on ...field.Expr) IAgreementVersionDo
	Group(cols ...field.Expr) IAgreementVersionDo
	Having(conds ...gen.Condition) IAgreementVersionDo
	Limit(limit int) IAgreementVersionDo
	Offset(offset int) IAgreementVersionDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IAgreementVersionDo
	Unscoped() IAgreementVersionDo
	Create(values ...*model.AgreementVersion) error
	CreateInBatches(values []*model.AgreementVersion, batchSize int) error
	Save(values ...*model.AgreementVersion) error
	First() (*model.AgreementVersion, error)
	Take() (*model.AgreementVersion, error)
	Last() (*model.AgreementVersion, error)
	Find() ([]*model.AgreementVersion, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AgreementVersion, err error)
	FindInBatches(result *[]*model.AgreementVersion, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.AgreementVersion) (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) IAgreementVersionDo
	Assign(attrs ...field.AssignExpr) IAgreementVersionDo
	Joins(fields ...field.RelationField) IAgreementVersionDo
	Preload(fields ...field.RelationField) IAgreementVersionDo
	FirstOrInit() (*model.AgreementVersion, error)
	FirstOrCreate() (*model.AgreementVersion, error)
	FindByPage(offset int, limit int) (result []*model.AgreementVersion, 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) IAgreementVersionDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IConfigDo

type IConfigDo interface {
	gen.SubQuery
	Debug() IConfigDo
	WithContext(ctx context.Context) IConfigDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IConfigDo
	WriteDB() IConfigDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IConfigDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IConfigDo
	Not(conds ...gen.Condition) IConfigDo
	Or(conds ...gen.Condition) IConfigDo
	Select(conds ...field.Expr) IConfigDo
	Where(conds ...gen.Condition) IConfigDo
	Order(conds ...field.Expr) IConfigDo
	Distinct(cols ...field.Expr) IConfigDo
	Omit(cols ...field.Expr) IConfigDo
	Join(table schema.Tabler, on ...field.Expr) IConfigDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IConfigDo
	RightJoin(table schema.Tabler, on ...field.Expr) IConfigDo
	Group(cols ...field.Expr) IConfigDo
	Having(conds ...gen.Condition) IConfigDo
	Limit(limit int) IConfigDo
	Offset(offset int) IConfigDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IConfigDo
	Unscoped() IConfigDo
	Create(values ...*model.Config) error
	CreateInBatches(values []*model.Config, batchSize int) error
	Save(values ...*model.Config) error
	First() (*model.Config, error)
	Take() (*model.Config, error)
	Last() (*model.Config, error)
	Find() ([]*model.Config, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Config, err error)
	FindInBatches(result *[]*model.Config, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.Config) (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) IConfigDo
	Assign(attrs ...field.AssignExpr) IConfigDo
	Joins(fields ...field.RelationField) IConfigDo
	Preload(fields ...field.RelationField) IConfigDo
	FirstOrInit() (*model.Config, error)
	FirstOrCreate() (*model.Config, error)
	FindByPage(offset int, limit int) (result []*model.Config, 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) IConfigDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IGithubAccountDo

type IGithubAccountDo interface {
	gen.SubQuery
	Debug() IGithubAccountDo
	WithContext(ctx context.Context) IGithubAccountDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IGithubAccountDo
	WriteDB() IGithubAccountDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IGithubAccountDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IGithubAccountDo
	Not(conds ...gen.Condition) IGithubAccountDo
	Or(conds ...gen.Condition) IGithubAccountDo
	Select(conds ...field.Expr) IGithubAccountDo
	Where(conds ...gen.Condition) IGithubAccountDo
	Order(conds ...field.Expr) IGithubAccountDo
	Distinct(cols ...field.Expr) IGithubAccountDo
	Omit(cols ...field.Expr) IGithubAccountDo
	Join(table schema.Tabler, on ...field.Expr) IGithubAccountDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IGithubAccountDo
	RightJoin(table schema.Tabler, on ...field.Expr) IGithubAccountDo
	Group(cols ...field.Expr) IGithubAccountDo
	Having(conds ...gen.Condition) IGithubAccountDo
	Limit(limit int) IGithubAccountDo
	Offset(offset int) IGithubAccountDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IGithubAccountDo
	Unscoped() IGithubAccountDo
	Create(values ...*model.GithubAccount) error
	CreateInBatches(values []*model.GithubAccount, batchSize int) error
	Save(values ...*model.GithubAccount) error
	First() (*model.GithubAccount, error)
	Take() (*model.GithubAccount, error)
	Last() (*model.GithubAccount, error)
	Find() ([]*model.GithubAccount, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.GithubAccount, err error)
	FindInBatches(result *[]*model.GithubAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.GithubAccount) (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) IGithubAccountDo
	Assign(attrs ...field.AssignExpr) IGithubAccountDo
	Joins(fields ...field.RelationField) IGithubAccountDo
	Preload(fields ...field.RelationField) IGithubAccountDo
	FirstOrInit() (*model.GithubAccount, error)
	FirstOrCreate() (*model.GithubAccount, error)
	FindByPage(offset int, limit int) (result []*model.GithubAccount, 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) IGithubAccountDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type ISessionKeyDo

type ISessionKeyDo interface {
	gen.SubQuery
	Debug() ISessionKeyDo
	WithContext(ctx context.Context) ISessionKeyDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() ISessionKeyDo
	WriteDB() ISessionKeyDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) ISessionKeyDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) ISessionKeyDo
	Not(conds ...gen.Condition) ISessionKeyDo
	Or(conds ...gen.Condition) ISessionKeyDo
	Select(conds ...field.Expr) ISessionKeyDo
	Where(conds ...gen.Condition) ISessionKeyDo
	Order(conds ...field.Expr) ISessionKeyDo
	Distinct(cols ...field.Expr) ISessionKeyDo
	Omit(cols ...field.Expr) ISessionKeyDo
	Join(table schema.Tabler, on ...field.Expr) ISessionKeyDo
	LeftJoin(table schema.Tabler, on ...field.Expr) ISessionKeyDo
	RightJoin(table schema.Tabler, on ...field.Expr) ISessionKeyDo
	Group(cols ...field.Expr) ISessionKeyDo
	Having(conds ...gen.Condition) ISessionKeyDo
	Limit(limit int) ISessionKeyDo
	Offset(offset int) ISessionKeyDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) ISessionKeyDo
	Unscoped() ISessionKeyDo
	Create(values ...*model.SessionKey) error
	CreateInBatches(values []*model.SessionKey, batchSize int) error
	Save(values ...*model.SessionKey) error
	First() (*model.SessionKey, error)
	Take() (*model.SessionKey, error)
	Last() (*model.SessionKey, error)
	Find() ([]*model.SessionKey, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.SessionKey, err error)
	FindInBatches(result *[]*model.SessionKey, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.SessionKey) (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) ISessionKeyDo
	Assign(attrs ...field.AssignExpr) ISessionKeyDo
	Joins(fields ...field.RelationField) ISessionKeyDo
	Preload(fields ...field.RelationField) ISessionKeyDo
	FirstOrInit() (*model.SessionKey, error)
	FirstOrCreate() (*model.SessionKey, error)
	FindByPage(offset int, limit int) (result []*model.SessionKey, 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) ISessionKeyDo
	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 IUserSignatureDo

type IUserSignatureDo interface {
	gen.SubQuery
	Debug() IUserSignatureDo
	WithContext(ctx context.Context) IUserSignatureDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IUserSignatureDo
	WriteDB() IUserSignatureDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IUserSignatureDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IUserSignatureDo
	Not(conds ...gen.Condition) IUserSignatureDo
	Or(conds ...gen.Condition) IUserSignatureDo
	Select(conds ...field.Expr) IUserSignatureDo
	Where(conds ...gen.Condition) IUserSignatureDo
	Order(conds ...field.Expr) IUserSignatureDo
	Distinct(cols ...field.Expr) IUserSignatureDo
	Omit(cols ...field.Expr) IUserSignatureDo
	Join(table schema.Tabler, on ...field.Expr) IUserSignatureDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IUserSignatureDo
	RightJoin(table schema.Tabler, on ...field.Expr) IUserSignatureDo
	Group(cols ...field.Expr) IUserSignatureDo
	Having(conds ...gen.Condition) IUserSignatureDo
	Limit(limit int) IUserSignatureDo
	Offset(offset int) IUserSignatureDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserSignatureDo
	Unscoped() IUserSignatureDo
	Create(values ...*model.UserSignature) error
	CreateInBatches(values []*model.UserSignature, batchSize int) error
	Save(values ...*model.UserSignature) error
	First() (*model.UserSignature, error)
	Take() (*model.UserSignature, error)
	Last() (*model.UserSignature, error)
	Find() ([]*model.UserSignature, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.UserSignature, err error)
	FindInBatches(result *[]*model.UserSignature, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.UserSignature) (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) IUserSignatureDo
	Assign(attrs ...field.AssignExpr) IUserSignatureDo
	Joins(fields ...field.RelationField) IUserSignatureDo
	Preload(fields ...field.RelationField) IUserSignatureDo
	FirstOrInit() (*model.UserSignature, error)
	FirstOrCreate() (*model.UserSignature, error)
	FindByPage(offset int, limit int) (result []*model.UserSignature, 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) IUserSignatureDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type IVerifyCodeDo

type IVerifyCodeDo interface {
	gen.SubQuery
	Debug() IVerifyCodeDo
	WithContext(ctx context.Context) IVerifyCodeDo
	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
	ReplaceDB(db *gorm.DB)
	ReadDB() IVerifyCodeDo
	WriteDB() IVerifyCodeDo
	As(alias string) gen.Dao
	Session(config *gorm.Session) IVerifyCodeDo
	Columns(cols ...field.Expr) gen.Columns
	Clauses(conds ...clause.Expression) IVerifyCodeDo
	Not(conds ...gen.Condition) IVerifyCodeDo
	Or(conds ...gen.Condition) IVerifyCodeDo
	Select(conds ...field.Expr) IVerifyCodeDo
	Where(conds ...gen.Condition) IVerifyCodeDo
	Order(conds ...field.Expr) IVerifyCodeDo
	Distinct(cols ...field.Expr) IVerifyCodeDo
	Omit(cols ...field.Expr) IVerifyCodeDo
	Join(table schema.Tabler, on ...field.Expr) IVerifyCodeDo
	LeftJoin(table schema.Tabler, on ...field.Expr) IVerifyCodeDo
	RightJoin(table schema.Tabler, on ...field.Expr) IVerifyCodeDo
	Group(cols ...field.Expr) IVerifyCodeDo
	Having(conds ...gen.Condition) IVerifyCodeDo
	Limit(limit int) IVerifyCodeDo
	Offset(offset int) IVerifyCodeDo
	Count() (count int64, err error)
	Scopes(funcs ...func(gen.Dao) gen.Dao) IVerifyCodeDo
	Unscoped() IVerifyCodeDo
	Create(values ...*model.VerifyCode) error
	CreateInBatches(values []*model.VerifyCode, batchSize int) error
	Save(values ...*model.VerifyCode) error
	First() (*model.VerifyCode, error)
	Take() (*model.VerifyCode, error)
	Last() (*model.VerifyCode, error)
	Find() ([]*model.VerifyCode, error)
	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.VerifyCode, err error)
	FindInBatches(result *[]*model.VerifyCode, batchSize int, fc func(tx gen.Dao, batch int) error) error
	Pluck(column field.Expr, dest interface{}) error
	Delete(...*model.VerifyCode) (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) IVerifyCodeDo
	Assign(attrs ...field.AssignExpr) IVerifyCodeDo
	Joins(fields ...field.RelationField) IVerifyCodeDo
	Preload(fields ...field.RelationField) IVerifyCodeDo
	FirstOrInit() (*model.VerifyCode, error)
	FirstOrCreate() (*model.VerifyCode, error)
	FindByPage(offset int, limit int) (result []*model.VerifyCode, 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) IVerifyCodeDo
	UnderlyingDB() *gorm.DB
	schema.Tabler
}

type Query

type Query struct {
	Account          account
	AccountConnect   accountConnect
	Agreement        agreement
	AgreementVersion agreementVersion
	Config           config
	GithubAccount    githubAccount
	SessionKey       sessionKey
	User             user
	UserSignature    userSignature
	VerifyCode       verifyCode
	// 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