zz_generated.ioc.go

//go:build !ignore_autogenerated
// +build !ignore_autogenerated

// Code generated by iocli, run 'iocli gen' to re-generate

package postgres

import (
	contextx "context"
	"database/sql"
	"github.com/alibaba/ioc-golang/autowire"
	normal "github.com/alibaba/ioc-golang/autowire/normal"
	singleton "github.com/alibaba/ioc-golang/autowire/singleton"
	util "github.com/alibaba/ioc-golang/autowire/util"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
)

func init() {
	normal.RegisterStructDescriptor(&autowire.StructDescriptor{
		Factory: func() interface{} {
			return &pgDB_{}
		},
	})
	pgDBStructDescriptor := &autowire.StructDescriptor{
		Factory: func() interface{} {
			return &PgDB{}
		},
		ParamFactory: func() interface{} {
			var _ paramInterface = &Param{}
			return &Param{}
		},
		ConstructFunc: func(i interface{}, p interface{}) (interface{}, error) {
			param := p.(paramInterface)
			impl := i.(*PgDB)
			return param.New(impl)
		},
		Metadata: map[string]interface{}{
			"aop":      map[string]interface{}{},
			"autowire": map[string]interface{}{},
		},
	}
	normal.RegisterStructDescriptor(pgDBStructDescriptor)
	singleton.RegisterStructDescriptor(pgDBStructDescriptor)
}

type paramInterface interface {
	New(impl *PgDB) (*PgDB, error)
}
type pgDB_ struct {
	Session_         func(config *gorm.Session) PgDBIOCInterface
	WithContext_     func(ctx contextx.Context) PgDBIOCInterface
	Debug_           func() PgDBIOCInterface
	GetDB_           func() *gorm.DB
	Set_             func(key string, value interface{}) PgDBIOCInterface
	Get_             func(key string) (interface{}, bool)
	InstanceSet_     func(key string, value interface{}) PgDBIOCInterface
	InstanceGet_     func(key string) (interface{}, bool)
	AddError_        func(err error) error
	DB_              func() (*sql.DB, error)
	SetupJoinTable_  func(model interface{}, field string, joinTable interface{}) error
	Use_             func(plugin gorm.Plugin) error
	ToSQL_           func(queryFn func(tx *gorm.DB) *gorm.DB) string
	Model_           func(value interface{}) PgDBIOCInterface
	Clauses_         func(conds ...clause.Expression) PgDBIOCInterface
	Table_           func(name string, args ...interface{}) PgDBIOCInterface
	Distinct_        func(args ...interface{}) PgDBIOCInterface
	Select_          func(query interface{}, args ...interface{}) PgDBIOCInterface
	Omit_            func(columns ...string) PgDBIOCInterface
	Where_           func(query interface{}, args ...interface{}) PgDBIOCInterface
	Not_             func(query interface{}, args ...interface{}) PgDBIOCInterface
	Or_              func(query interface{}, args ...interface{}) PgDBIOCInterface
	Joins_           func(query string, args ...interface{}) PgDBIOCInterface
	Group_           func(name string) PgDBIOCInterface
	Having_          func(query interface{}, args ...interface{}) PgDBIOCInterface
	Order_           func(value interface{}) PgDBIOCInterface
	Limit_           func(limit int) PgDBIOCInterface
	Offset_          func(offset int) PgDBIOCInterface
	Scopes_          func(funcs ...func(db *gorm.DB) *gorm.DB) PgDBIOCInterface
	Preload_         func(query string, args ...interface{}) PgDBIOCInterface
	Attrs_           func(attrs ...interface{}) PgDBIOCInterface
	Assign_          func(attrs ...interface{}) PgDBIOCInterface
	Unscoped_        func() PgDBIOCInterface
	Raw_             func(sql string, values ...interface{}) PgDBIOCInterface
	Error_           func() error
	Create_          func(value interface{}) PgDBIOCInterface
	CreateInBatches_ func(value interface{}, batchSize int) PgDBIOCInterface
	Save_            func(value interface{}) PgDBIOCInterface
	First_           func(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Take_            func(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Last_            func(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Find_            func(dest interface{}, conds ...interface{}) PgDBIOCInterface
	FindInBatches_   func(dest interface{}, batchSize int, fc func(tx *gorm.DB, batch int) error) PgDBIOCInterface
	FirstOrInit_     func(dest interface{}, conds ...interface{}) PgDBIOCInterface
	FirstOrCreate_   func(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Update_          func(column string, value interface{}) PgDBIOCInterface
	Updates_         func(values interface{}) PgDBIOCInterface
	UpdateColumn_    func(column string, value interface{}) PgDBIOCInterface
	UpdateColumns_   func(values interface{}) PgDBIOCInterface
	Delete_          func(value interface{}, conds ...interface{}) PgDBIOCInterface
	Count_           func(count *int64) PgDBIOCInterface
	Row_             func() *sql.Row
	Rows_            func() (*sql.Rows, error)
	Scan_            func(dest interface{}) PgDBIOCInterface
	Pluck_           func(column string, dest interface{}) PgDBIOCInterface
	ScanRows_        func(rows *sql.Rows, dest interface{}) error
	Connection_      func(fc func(db *gorm.DB) error) (err error)
	Transaction_     func(fc func(db *gorm.DB) error, opts ...*sql.TxOptions) (err error)
	Begin_           func(opts ...*sql.TxOptions) PgDBIOCInterface
	Commit_          func() PgDBIOCInterface
	Rollback_        func()
	SavePoint_       func(name string) PgDBIOCInterface
	RollbackTo_      func(name string) PgDBIOCInterface
	Exec_            func(sql string, values ...interface{}) PgDBIOCInterface
	Migrator_        func() gorm.Migrator
	AutoMigrate_     func(dst ...interface{}) error
	Association_     func(column string) *gorm.Association
}

func (p *pgDB_) Session(config *gorm.Session) PgDBIOCInterface {
	return p.Session_(config)
}

func (p *pgDB_) WithContext(ctx contextx.Context) PgDBIOCInterface {
	return p.WithContext_(ctx)
}

func (p *pgDB_) Debug() PgDBIOCInterface {
	return p.Debug_()
}

func (p *pgDB_) GetDB() *gorm.DB {
	return p.GetDB_()
}

func (p *pgDB_) Set(key string, value interface{}) PgDBIOCInterface {
	return p.Set_(key, value)
}

func (p *pgDB_) Get(key string) (interface{}, bool) {
	return p.Get_(key)
}

func (p *pgDB_) InstanceSet(key string, value interface{}) PgDBIOCInterface {
	return p.InstanceSet_(key, value)
}

func (p *pgDB_) InstanceGet(key string) (interface{}, bool) {
	return p.InstanceGet_(key)
}

func (p *pgDB_) AddError(err error) error {
	return p.AddError_(err)
}

func (p *pgDB_) DB() (*sql.DB, error) {
	return p.DB_()
}

func (p *pgDB_) SetupJoinTable(model interface{}, field string, joinTable interface{}) error {
	return p.SetupJoinTable_(model, field, joinTable)
}

func (p *pgDB_) Use(plugin gorm.Plugin) error {
	return p.Use_(plugin)
}

func (p *pgDB_) ToSQL(queryFn func(tx *gorm.DB) *gorm.DB) string {
	return p.ToSQL_(queryFn)
}

func (p *pgDB_) Model(value interface{}) PgDBIOCInterface {
	return p.Model_(value)
}

func (p *pgDB_) Clauses(conds ...clause.Expression) PgDBIOCInterface {
	return p.Clauses_(conds...)
}

func (p *pgDB_) Table(name string, args ...interface{}) PgDBIOCInterface {
	return p.Table_(name, args...)
}

func (p *pgDB_) Distinct(args ...interface{}) PgDBIOCInterface {
	return p.Distinct_(args...)
}

func (p *pgDB_) Select(query interface{}, args ...interface{}) PgDBIOCInterface {
	return p.Select_(query, args...)
}

func (p *pgDB_) Omit(columns ...string) PgDBIOCInterface {
	return p.Omit_(columns...)
}

func (p *pgDB_) Where(query interface{}, args ...interface{}) PgDBIOCInterface {
	return p.Where_(query, args...)
}

func (p *pgDB_) Not(query interface{}, args ...interface{}) PgDBIOCInterface {
	return p.Not_(query, args...)
}

func (p *pgDB_) Or(query interface{}, args ...interface{}) PgDBIOCInterface {
	return p.Or_(query, args...)
}

func (p *pgDB_) Joins(query string, args ...interface{}) PgDBIOCInterface {
	return p.Joins_(query, args...)
}

func (p *pgDB_) Group(name string) PgDBIOCInterface {
	return p.Group_(name)
}

func (p *pgDB_) Having(query interface{}, args ...interface{}) PgDBIOCInterface {
	return p.Having_(query, args...)
}

func (p *pgDB_) Order(value interface{}) PgDBIOCInterface {
	return p.Order_(value)
}

func (p *pgDB_) Limit(limit int) PgDBIOCInterface {
	return p.Limit_(limit)
}

func (p *pgDB_) Offset(offset int) PgDBIOCInterface {
	return p.Offset_(offset)
}

func (p *pgDB_) Scopes(funcs ...func(db *gorm.DB) *gorm.DB) PgDBIOCInterface {
	return p.Scopes_(funcs...)
}

func (p *pgDB_) Preload(query string, args ...interface{}) PgDBIOCInterface {
	return p.Preload_(query, args...)
}

func (p *pgDB_) Attrs(attrs ...interface{}) PgDBIOCInterface {
	return p.Attrs_(attrs...)
}

func (p *pgDB_) Assign(attrs ...interface{}) PgDBIOCInterface {
	return p.Assign_(attrs...)
}

func (p *pgDB_) Unscoped() PgDBIOCInterface {
	return p.Unscoped_()
}

func (p *pgDB_) Raw(sql string, values ...interface{}) PgDBIOCInterface {
	return p.Raw_(sql, values...)
}

func (p *pgDB_) Error() error {
	return p.Error_()
}

func (p *pgDB_) Create(value interface{}) PgDBIOCInterface {
	return p.Create_(value)
}

func (p *pgDB_) CreateInBatches(value interface{}, batchSize int) PgDBIOCInterface {
	return p.CreateInBatches_(value, batchSize)
}

func (p *pgDB_) Save(value interface{}) PgDBIOCInterface {
	return p.Save_(value)
}

func (p *pgDB_) First(dest interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.First_(dest, conds...)
}

func (p *pgDB_) Take(dest interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.Take_(dest, conds...)
}

func (p *pgDB_) Last(dest interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.Last_(dest, conds...)
}

func (p *pgDB_) Find(dest interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.Find_(dest, conds...)
}

func (p *pgDB_) FindInBatches(dest interface{}, batchSize int, fc func(tx *gorm.DB, batch int) error) PgDBIOCInterface {
	return p.FindInBatches_(dest, batchSize, fc)
}

func (p *pgDB_) FirstOrInit(dest interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.FirstOrInit_(dest, conds...)
}

func (p *pgDB_) FirstOrCreate(dest interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.FirstOrCreate_(dest, conds...)
}

func (p *pgDB_) Update(column string, value interface{}) PgDBIOCInterface {
	return p.Update_(column, value)
}

func (p *pgDB_) Updates(values interface{}) PgDBIOCInterface {
	return p.Updates_(values)
}

func (p *pgDB_) UpdateColumn(column string, value interface{}) PgDBIOCInterface {
	return p.UpdateColumn_(column, value)
}

func (p *pgDB_) UpdateColumns(values interface{}) PgDBIOCInterface {
	return p.UpdateColumns_(values)
}

func (p *pgDB_) Delete(value interface{}, conds ...interface{}) PgDBIOCInterface {
	return p.Delete_(value, conds...)
}

func (p *pgDB_) Count(count *int64) PgDBIOCInterface {
	return p.Count_(count)
}

func (p *pgDB_) Row() *sql.Row {
	return p.Row_()
}

func (p *pgDB_) Rows() (*sql.Rows, error) {
	return p.Rows_()
}

func (p *pgDB_) Scan(dest interface{}) PgDBIOCInterface {
	return p.Scan_(dest)
}

func (p *pgDB_) Pluck(column string, dest interface{}) PgDBIOCInterface {
	return p.Pluck_(column, dest)
}

func (p *pgDB_) ScanRows(rows *sql.Rows, dest interface{}) error {
	return p.ScanRows_(rows, dest)
}

func (p *pgDB_) Connection(fc func(db *gorm.DB) error) (err error) {
	return p.Connection_(fc)
}

func (p *pgDB_) Transaction(fc func(db *gorm.DB) error, opts ...*sql.TxOptions) (err error) {
	return p.Transaction_(fc, opts...)
}

func (p *pgDB_) Begin(opts ...*sql.TxOptions) PgDBIOCInterface {
	return p.Begin_(opts...)
}

func (p *pgDB_) Commit() PgDBIOCInterface {
	return p.Commit_()
}

func (p *pgDB_) Rollback() {
	p.Rollback_()
}

func (p *pgDB_) SavePoint(name string) PgDBIOCInterface {
	return p.SavePoint_(name)
}

func (p *pgDB_) RollbackTo(name string) PgDBIOCInterface {
	return p.RollbackTo_(name)
}

func (p *pgDB_) Exec(sql string, values ...interface{}) PgDBIOCInterface {
	return p.Exec_(sql, values...)
}

func (p *pgDB_) Migrator() gorm.Migrator {
	return p.Migrator_()
}

func (p *pgDB_) AutoMigrate(dst ...interface{}) error {
	return p.AutoMigrate_(dst...)
}

func (p *pgDB_) Association(column string) *gorm.Association {
	return p.Association_(column)
}

type PgDBIOCInterface interface {
	Session(config *gorm.Session) PgDBIOCInterface
	WithContext(ctx contextx.Context) PgDBIOCInterface
	Debug() PgDBIOCInterface
	GetDB() *gorm.DB
	Set(key string, value interface{}) PgDBIOCInterface
	Get(key string) (interface{}, bool)
	InstanceSet(key string, value interface{}) PgDBIOCInterface
	InstanceGet(key string) (interface{}, bool)
	AddError(err error) error
	DB() (*sql.DB, error)
	SetupJoinTable(model interface{}, field string, joinTable interface{}) error
	Use(plugin gorm.Plugin) error
	ToSQL(queryFn func(tx *gorm.DB) *gorm.DB) string
	Model(value interface{}) PgDBIOCInterface
	Clauses(conds ...clause.Expression) PgDBIOCInterface
	Table(name string, args ...interface{}) PgDBIOCInterface
	Distinct(args ...interface{}) PgDBIOCInterface
	Select(query interface{}, args ...interface{}) PgDBIOCInterface
	Omit(columns ...string) PgDBIOCInterface
	Where(query interface{}, args ...interface{}) PgDBIOCInterface
	Not(query interface{}, args ...interface{}) PgDBIOCInterface
	Or(query interface{}, args ...interface{}) PgDBIOCInterface
	Joins(query string, args ...interface{}) PgDBIOCInterface
	Group(name string) PgDBIOCInterface
	Having(query interface{}, args ...interface{}) PgDBIOCInterface
	Order(value interface{}) PgDBIOCInterface
	Limit(limit int) PgDBIOCInterface
	Offset(offset int) PgDBIOCInterface
	Scopes(funcs ...func(db *gorm.DB) *gorm.DB) PgDBIOCInterface
	Preload(query string, args ...interface{}) PgDBIOCInterface
	Attrs(attrs ...interface{}) PgDBIOCInterface
	Assign(attrs ...interface{}) PgDBIOCInterface
	Unscoped() PgDBIOCInterface
	Raw(sql string, values ...interface{}) PgDBIOCInterface
	Error() error
	Create(value interface{}) PgDBIOCInterface
	CreateInBatches(value interface{}, batchSize int) PgDBIOCInterface
	Save(value interface{}) PgDBIOCInterface
	First(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Take(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Last(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Find(dest interface{}, conds ...interface{}) PgDBIOCInterface
	FindInBatches(dest interface{}, batchSize int, fc func(tx *gorm.DB, batch int) error) PgDBIOCInterface
	FirstOrInit(dest interface{}, conds ...interface{}) PgDBIOCInterface
	FirstOrCreate(dest interface{}, conds ...interface{}) PgDBIOCInterface
	Update(column string, value interface{}) PgDBIOCInterface
	Updates(values interface{}) PgDBIOCInterface
	UpdateColumn(column string, value interface{}) PgDBIOCInterface
	UpdateColumns(values interface{}) PgDBIOCInterface
	Delete(value interface{}, conds ...interface{}) PgDBIOCInterface
	Count(count *int64) PgDBIOCInterface
	Row() *sql.Row
	Rows() (*sql.Rows, error)
	Scan(dest interface{}) PgDBIOCInterface
	Pluck(column string, dest interface{}) PgDBIOCInterface
	ScanRows(rows *sql.Rows, dest interface{}) error
	Connection(fc func(db *gorm.DB) error) (err error)
	Transaction(fc func(db *gorm.DB) error, opts ...*sql.TxOptions) (err error)
	Begin(opts ...*sql.TxOptions) PgDBIOCInterface
	Commit() PgDBIOCInterface
	Rollback()
	SavePoint(name string) PgDBIOCInterface
	RollbackTo(name string) PgDBIOCInterface
	Exec(sql string, values ...interface{}) PgDBIOCInterface
	Migrator() gorm.Migrator
	AutoMigrate(dst ...interface{}) error
	Association(column string) *gorm.Association
}

var _pgDBSDID string

func GetPgDB(p *Param) (*PgDB, error) {
	if _pgDBSDID == "" {
		_pgDBSDID = util.GetSDIDByStructPtr(new(PgDB))
	}
	i, err := normal.GetImpl(_pgDBSDID, p)
	if err != nil {
		return nil, err
	}
	impl := i.(*PgDB)
	return impl, nil
}

func GetPgDBIOCInterface(p *Param) (PgDBIOCInterface, error) {
	if _pgDBSDID == "" {
		_pgDBSDID = util.GetSDIDByStructPtr(new(PgDB))
	}
	i, err := normal.GetImplWithProxy(_pgDBSDID, p)
	if err != nil {
		return nil, err
	}
	impl := i.(PgDBIOCInterface)
	return impl, nil
}

func GetPgDBSingleton(p *Param) (*PgDB, error) {
	if _pgDBSDID == "" {
		_pgDBSDID = util.GetSDIDByStructPtr(new(PgDB))
	}
	i, err := singleton.GetImpl(_pgDBSDID, p)
	if err != nil {
		return nil, err
	}
	impl := i.(*PgDB)
	return impl, nil
}

func GetPgDBIOCInterfaceSingleton(p *Param) (PgDBIOCInterface, error) {
	if _pgDBSDID == "" {
		_pgDBSDID = util.GetSDIDByStructPtr(new(PgDB))
	}
	i, err := singleton.GetImplWithProxy(_pgDBSDID, p)
	if err != nil {
		return nil, err
	}
	impl := i.(PgDBIOCInterface)
	return impl, nil
}