dal

Documentation

Index

• Variables
• func SetDefault(db *gorm.DB, opts ...gen.DOOption)
• type ICommitDo
• type ICommitFileDo
• type IFileBlobDo
• type IRepositoryDo
• type ITagDo
• type ITokenDo
• type IUserDo
• 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)
	Commit     *commit
	CommitFile *commitFile
	FileBlob   *fileBlob
	Repository *repository
	Tag        *tag
	Token      *token
	User       *user
)

Functions

func SetDefault

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

Types

type ICommitDo

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

type ICommitFileDo

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

type IFileBlobDo

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

type IRepositoryDo

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

type ITagDo

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

type ITokenDo

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

type Query struct {
	Commit     commit
	CommitFile commitFile
	FileBlob   fileBlob
	Repository repository
	Tag        tag
	Token      token
	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