gen

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IActorDo
• type IAppVersionDo
• type IEpisodeDo
• type IGenreDo
• type IKeywordDo
• type IMovieDo
• type ISeasonDo
• type ISeriesDo
• type IStudioDo
• type IUserDo
• type IVideoActorMappingDo
• type IVideoGenreMappingDo
• type IVideoKeywordMappingDo
• type IVideoStudioMappingDo
• type IVideoSubtitleMappingDo
• type IVideoUserMappingDo
• type Query
  • func Use(db *gorm.DB, opts ...gen.DOOption) *Query
  • func (q *Query) Available() bool
  • func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx
  • func (q *Query) ReadDB() *Query
  • func (q *Query) ReplaceDB(db *gorm.DB) *Query
  • func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error
  • func (q *Query) WithContext(ctx context.Context) *queryCtx
  • func (q *Query) WriteDB() *Query
• type QueryTx
  • func (q *QueryTx) Commit() error
  • func (q *QueryTx) Rollback() error
  • func (q *QueryTx) RollbackTo(name string) error
  • func (q *QueryTx) SavePoint(name string) error

Variables

var (
	Q                    = new(Query)
	Actor                *actor
	AppVersion           *appVersion
	Episode              *episode
	Genre                *genre
	Keyword              *keyword
	Movie                *movie
	Season               *season
	Series               *series
	Studio               *studio
	User                 *user
	VideoActorMapping    *videoActorMapping
	VideoGenreMapping    *videoGenreMapping
	VideoKeywordMapping  *videoKeywordMapping
	VideoStudioMapping   *videoStudioMapping
	VideoSubtitleMapping *videoSubtitleMapping
	VideoUserMapping     *videoUserMapping
)

Functions

func SetDefault

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

Types

type IActorDo

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

	SelectByID(id int64) (result *model.Actor, err error)
}

type IAppVersionDo

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

	SelectByID(id int64) (result *model.AppVersion, err error)
}

type IEpisodeDo

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

	SelectByID(id int64) (result *model.Episode, err error)
}

type IGenreDo

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

	SelectByID(id int64) (result *model.Genre, err error)
}

type IKeywordDo

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

	SelectByID(id int64) (result *model.Keyword, err error)
}

type IMovieDo

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

	SelectByID(id int64) (result *model.Movie, err error)
}

type ISeasonDo

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

	SelectByID(id int64) (result *model.Season, err error)
}

type ISeriesDo

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

	SelectByID(id int64) (result *model.Series, err error)
}

type IStudioDo

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

	SelectByID(id int64) (result *model.Studio, 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
	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

	SelectByID(id int64) (result *model.User, err error)
}

type IVideoActorMappingDo

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

	SelectByID(id int64) (result *model.VideoActorMapping, err error)
}

type IVideoGenreMappingDo

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

	SelectByID(id int64) (result *model.VideoGenreMapping, err error)
}

type IVideoKeywordMappingDo

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

	SelectByID(id int64) (result *model.VideoKeywordMapping, err error)
}

type IVideoStudioMappingDo

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

	SelectByID(id int64) (result *model.VideoStudioMapping, err error)
}

type IVideoSubtitleMappingDo

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

	SelectByID(id int64) (result *model.VideoSubtitleMapping, err error)
}

type IVideoUserMappingDo

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

	SelectByID(id int64) (result *model.VideoUserMapping, err error)
}

type Query

type Query struct {
	Actor                actor
	AppVersion           appVersion
	Episode              episode
	Genre                genre
	Keyword              keyword
	Movie                movie
	Season               season
	Series               series
	Studio               studio
	User                 user
	VideoActorMapping    videoActorMapping
	VideoGenreMapping    videoGenreMapping
	VideoKeywordMapping  videoKeywordMapping
	VideoStudioMapping   videoStudioMapping
	VideoSubtitleMapping videoSubtitleMapping
	VideoUserMapping     videoUserMapping
	// contains filtered or unexported fields
}

func Use

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

func (*Query) Available

func (q *Query) Available() bool

func (*Query) Begin

func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx

func (*Query) ReadDB

func (q *Query) ReadDB() *Query

func (*Query) ReplaceDB

func (q *Query) ReplaceDB(db *gorm.DB) *Query

func (*Query) Transaction

func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error

func (*Query) WithContext

func (q *Query) WithContext(ctx context.Context) *queryCtx

func (*Query) WriteDB

func (q *Query) WriteDB() *Query

type QueryTx

type QueryTx struct {
	*Query
	Error error
}

func (*QueryTx) Commit

func (q *QueryTx) Commit() error

func (*QueryTx) Rollback

func (q *QueryTx) Rollback() error

func (*QueryTx) RollbackTo

func (q *QueryTx) RollbackTo(name string) error

func (*QueryTx) SavePoint

func (q *QueryTx) SavePoint(name string) error