query

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type ICasbinRuleDo
• type IJwtBlacklistDo
• type ILogJobDo
• type ILogLoginDo
• type ILogOperDo
• type ISysAPIDo
• type ISysDeptDo
• type ISysDictDatumDo
• type ISysDictTypeDo
• type ISysDiscoveryDo
• type ISysJobDo
• type ISysLogDo
• type ISysMenuBtnDo
• type ISysMenuDo
• type ISysPostDo
• type ISysRoleBtnDo
• type ISysRoleDeptDo
• type ISysRoleDo
• type ISysRoleMenuDo
• type ISysUserDo
• 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)
	CasbinRule   *casbinRule
	JwtBlacklist *jwtBlacklist
	SysAPI       *sysAPI
	SysDept      *sysDept
	SysDictDatum *sysDictDatum
	SysDictType  *sysDictType
	SysLog       *sysLog
	SysMenu      *sysMenu
	SysMenuBtn   *sysMenuBtn
	SysPost      *sysPost
	SysRole      *sysRole
	SysRoleBtn   *sysRoleBtn
	SysRoleDept  *sysRoleDept
	SysRoleMenu  *sysRoleMenu
	SysUser      *sysUser
)

Functions

func SetDefault

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

Types

type ICasbinRuleDo

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

type IJwtBlacklistDo

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

type ILogJobDo

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

type ILogLoginDo

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

type ILogOperDo

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

type ISysAPIDo

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

type ISysDeptDo

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

type ISysDictDatumDo

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

type ISysDictTypeDo

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

type ISysDiscoveryDo

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

type ISysJobDo

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

type ISysLogDo

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

type ISysMenuBtnDo

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

type ISysMenuDo

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

type ISysPostDo

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

type ISysRoleBtnDo

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

type ISysRoleDeptDo

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

type ISysRoleDo

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

type ISysRoleMenuDo

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

type ISysUserDo

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

type Query

type Query struct {
	CasbinRule   casbinRule
	JwtBlacklist jwtBlacklist
	SysAPI       sysAPI
	SysDept      sysDept
	SysDictDatum sysDictDatum
	SysDictType  sysDictType
	SysLog       sysLog
	SysMenu      sysMenu
	SysMenuBtn   sysMenuBtn
	SysPost      sysPost
	SysRole      sysRole
	SysRoleBtn   sysRoleBtn
	SysRoleDept  sysRoleDept
	SysRoleMenu  sysRoleMenu
	SysUser      sysUser
	// 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