query

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

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

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

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

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

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

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

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

type Query struct {
	User          user
	UserFollow    userFollow
	UserFollower  userFollower
	UserInfo      userInfo
	UserMessage   userMessage
	VideoComment  videoComment
	VideoFavorite videoFavorite
	VideoInfo     videoInfo
	// contains filtered or unexported fields
}

type QueryTx struct{ *Query }