models_generated

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type IDiggerCiJobDo
• type IDiggerCiJobTokenDo
• type IGithubAppInstallationLinkDo
• type IOrgSettingDo
• type IOrganisationDo
• type IProjectDo
• type IRepoDo
• type IUserDo
• type IUserSettingDo
• 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)
	DiggerCiJob               *diggerCiJob
	DiggerCiJobToken          *diggerCiJobToken
	GithubAppInstallationLink *githubAppInstallationLink
	OrgSetting                *orgSetting
	Organisation              *organisation
	Project                   *project
	Repo                      *repo
	User                      *user
)

Functions

func SetDefault

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

Types

type IDiggerCiJobDo

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

type IDiggerCiJobTokenDo

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

type IGithubAppInstallationLinkDo

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

type IOrgSettingDo

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

type IOrganisationDo

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

type IProjectDo

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

type IRepoDo

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

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
}

type IUserSettingDo

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

type Query

type Query struct {
	DiggerCiJob               diggerCiJob
	DiggerCiJobToken          diggerCiJobToken
	GithubAppInstallationLink githubAppInstallationLink
	OrgSetting                orgSetting
	Organisation              organisation
	Project                   project
	Repo                      repo
	User                      user
	// 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