dal

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IArchivedCoinDo
• type IArchivedFavDo
• type IArchivedFavFolderDo
• type IArchivedLikeDo
• type IArchivedSeasonDo
• type IArchivedUpDo
• type IArchivedUpsTagDo
• type IArchivedVideoDo
• type IArchivedViewHistoryDo
• type ISchemaMigrationDo
• 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)
	ArchivedCoin        *archivedCoin
	ArchivedFav         *archivedFav
	ArchivedFavFolder   *archivedFavFolder
	ArchivedLike        *archivedLike
	ArchivedUp          *archivedUp
	ArchivedUpsTag      *archivedUpsTag
	ArchivedVideo       *archivedVideo
	ArchivedViewHistory *archivedViewHistory
)

Functions

func SetDefault

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

Types

type IArchivedCoinDo

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

type IArchivedFavDo

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

type IArchivedFavFolderDo

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

type IArchivedLikeDo

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

type IArchivedSeasonDo

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

type IArchivedUpDo

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

type IArchivedUpsTagDo

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

type IArchivedVideoDo

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

type IArchivedViewHistoryDo

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

type ISchemaMigrationDo

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

type Query

type Query struct {
	ArchivedCoin        archivedCoin
	ArchivedFav         archivedFav
	ArchivedFavFolder   archivedFavFolder
	ArchivedLike        archivedLike
	ArchivedUp          archivedUp
	ArchivedUpsTag      archivedUpsTag
	ArchivedVideo       archivedVideo
	ArchivedViewHistory archivedViewHistory
	// 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