query

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB)
• type IDeviceAckDo
• type IDeviceDo
• type IFeedDo
• type IFeedImageDo
• type IFeedLikeDo
• type IFeedVideoDo
• type IGidDo
• type IGoadminMenuDo
• type IGoadminOperationLogDo
• type IGoadminPermissionDo
• type IGoadminRoleDo
• type IGoadminRoleMenuDo
• type IGoadminRolePermissionDo
• type IGoadminRoleUserDo
• type IGoadminSessionDo
• type IGoadminSiteDo
• type IGoadminUserDo
• type IGoadminUserPermissionDo
• type IGroupDo
• type IGroupUserDo
• type IMessageContentDo
• type IMessageIndexDo
• type IUserDo
• type Query
  • func Use(db *gorm.DB) *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)
	Device                *device
	DeviceAck             *deviceAck
	Feed                  *feed
	FeedImage             *feedImage
	FeedLike              *feedLike
	FeedVideo             *feedVideo
	Gid                   *gid
	GoadminMenu           *goadminMenu
	GoadminOperationLog   *goadminOperationLog
	GoadminPermission     *goadminPermission
	GoadminRole           *goadminRole
	GoadminRoleMenu       *goadminRoleMenu
	GoadminRolePermission *goadminRolePermission
	GoadminRoleUser       *goadminRoleUser
	GoadminSession        *goadminSession
	GoadminSite           *goadminSite
	GoadminUser           *goadminUser
	GoadminUserPermission *goadminUserPermission
	Group                 *group
	GroupUser             *groupUser
	MessageContent        *messageContent
	MessageIndex          *messageIndex
	User                  *user
)

Functions

func SetDefault

func SetDefault(db *gorm.DB)

Types

type IDeviceAckDo

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

	GetById(id int) (result *model.DeviceAck, err error)
}

type IDeviceDo

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

	GetById(id int) (result *model.Device, err error)
}

type IFeedDo

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

	GetById(id int) (result *model.Feed, err error)
}

type IFeedImageDo

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

	GetById(id int) (result *model.FeedImage, err error)
}

type IFeedLikeDo

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

	GetById(id int) (result *model.FeedLike, err error)
}

type IFeedVideoDo

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

	GetById(id int) (result *model.FeedVideo, err error)
}

type IGidDo

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

	GetById(id int) (result *model.Gid, err error)
}

type IGoadminMenuDo

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

	GetById(id int) (result *model.GoadminMenu, err error)
}

type IGoadminOperationLogDo

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

	GetById(id int) (result *model.GoadminOperationLog, err error)
}

type IGoadminPermissionDo

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

	GetById(id int) (result *model.GoadminPermission, err error)
}

type IGoadminRoleDo

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

	GetById(id int) (result *model.GoadminRole, err error)
}

type IGoadminRoleMenuDo

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

	GetById(id int) (result *model.GoadminRoleMenu, err error)
}

type IGoadminRolePermissionDo

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

	GetById(id int) (result *model.GoadminRolePermission, err error)
}

type IGoadminRoleUserDo

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

	GetById(id int) (result *model.GoadminRoleUser, err error)
}

type IGoadminSessionDo

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

	GetById(id int) (result *model.GoadminSession, err error)
}

type IGoadminSiteDo

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

	GetById(id int) (result *model.GoadminSite, err error)
}

type IGoadminUserDo

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

	GetById(id int) (result *model.GoadminUser, err error)
}

type IGoadminUserPermissionDo

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

	GetById(id int) (result *model.GoadminUserPermission, err error)
}

type IGroupDo

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

	GetById(id int) (result *model.Group, err error)
}

type IGroupUserDo

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

	GetById(id int) (result *model.GroupUser, err error)
}

type IMessageContentDo

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

	GetById(id int) (result *model.MessageContent, err error)
}

type IMessageIndexDo

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

	GetById(id int) (result *model.MessageIndex, err error)
}

type IUserDo

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

	GetById(id int) (result *model.User, err error)
}

type Query

type Query struct {
	Device                device
	DeviceAck             deviceAck
	Feed                  feed
	FeedImage             feedImage
	FeedLike              feedLike
	FeedVideo             feedVideo
	Gid                   gid
	GoadminMenu           goadminMenu
	GoadminOperationLog   goadminOperationLog
	GoadminPermission     goadminPermission
	GoadminRole           goadminRole
	GoadminRoleMenu       goadminRoleMenu
	GoadminRolePermission goadminRolePermission
	GoadminRoleUser       goadminRoleUser
	GoadminSession        goadminSession
	GoadminSite           goadminSite
	GoadminUser           goadminUser
	GoadminUserPermission goadminUserPermission
	Group                 group
	GroupUser             groupUser
	MessageContent        messageContent
	MessageIndex          messageIndex
	User                  user
	// contains filtered or unexported fields
}

func Use

func Use(db *gorm.DB) *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 }

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