query

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type ISysDeptDo
• type ISysDictItemDo
• type ISysDictTypeDo
• type ISysLoginLogDo
• type ISysMenuDo
• type ISysOperateLogDo
• type ISysPostDo
• type ISysRoleDo
• type ISysRoleMenuDo
• type ISysUserDo
• type ISysUserPostDo
• type ISysUserRoleDo
• 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)
	SysDept       *sysDept
	SysDictItem   *sysDictItem
	SysDictType   *sysDictType
	SysLoginLog   *sysLoginLog
	SysMenu       *sysMenu
	SysOperateLog *sysOperateLog
	SysPost       *sysPost
	SysRole       *sysRole
	SysRoleMenu   *sysRoleMenu
	SysUser       *sysUser
	SysUserPost   *sysUserPost
	SysUserRole   *sysUserRole
)

Functions

func SetDefault

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

Types

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 ISysDictItemDo

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

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

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

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

type ISysUserRoleDo

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

type Query

type Query struct {
	SysDept       sysDept
	SysDictItem   sysDictItem
	SysDictType   sysDictType
	SysLoginLog   sysLoginLog
	SysMenu       sysMenu
	SysOperateLog sysOperateLog
	SysPost       sysPost
	SysRole       sysRole
	SysRoleMenu   sysRoleMenu
	SysUser       sysUser
	SysUserPost   sysUserPost
	SysUserRole   sysUserRole
	// 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