corporation.gen.go

// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.

package database

import (
	"context"

	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"

	"gorm.io/gen"
	"gorm.io/gen/field"

	"gorm.io/plugin/dbresolver"

	"github.com/buckbrady/evebot-tools-backend/pkg/model"
)

func newCorporation(db *gorm.DB, opts ...gen.DOOption) corporation {
	_corporation := corporation{}

	_corporation.corporationDo.UseDB(db, opts...)
	_corporation.corporationDo.UseModel(&model.Corporation{})

	tableName := _corporation.corporationDo.TableName()
	_corporation.ALL = field.NewAsterisk(tableName)
	_corporation.ID = field.NewInt32(tableName, "id")
	_corporation.AllianceID = field.NewInt32(tableName, "alliance_id")
	_corporation.CeoID = field.NewInt32(tableName, "ceo_id")
	_corporation.CreatorID = field.NewInt32(tableName, "creator_id")
	_corporation.DateFounded = field.NewTime(tableName, "date_founded")
	_corporation.Description = field.NewString(tableName, "description")
	_corporation.FactionID = field.NewInt32(tableName, "faction_id")
	_corporation.HomeStationID = field.NewInt32(tableName, "home_station_id")
	_corporation.MemberCount = field.NewInt32(tableName, "member_count")
	_corporation.Name = field.NewString(tableName, "name")
	_corporation.Shares = field.NewInt32(tableName, "shares")
	_corporation.TaxRate = field.NewFloat64(tableName, "tax_rate")
	_corporation.Ticker = field.NewString(tableName, "ticker")
	_corporation.URL = field.NewString(tableName, "url")
	_corporation.WarEligible = field.NewBool(tableName, "war_eligible")

	_corporation.fillFieldMap()

	return _corporation
}

type corporation struct {
	corporationDo corporationDo

	ALL           field.Asterisk
	ID            field.Int32
	AllianceID    field.Int32
	CeoID         field.Int32
	CreatorID     field.Int32
	DateFounded   field.Time
	Description   field.String
	FactionID     field.Int32
	HomeStationID field.Int32
	MemberCount   field.Int32
	Name          field.String
	Shares        field.Int32
	TaxRate       field.Float64
	Ticker        field.String
	URL           field.String
	WarEligible   field.Bool

	fieldMap map[string]field.Expr
}

func (c corporation) Table(newTableName string) *corporation {
	c.corporationDo.UseTable(newTableName)
	return c.updateTableName(newTableName)
}

func (c corporation) As(alias string) *corporation {
	c.corporationDo.DO = *(c.corporationDo.As(alias).(*gen.DO))
	return c.updateTableName(alias)
}

func (c *corporation) updateTableName(table string) *corporation {
	c.ALL = field.NewAsterisk(table)
	c.ID = field.NewInt32(table, "id")
	c.AllianceID = field.NewInt32(table, "alliance_id")
	c.CeoID = field.NewInt32(table, "ceo_id")
	c.CreatorID = field.NewInt32(table, "creator_id")
	c.DateFounded = field.NewTime(table, "date_founded")
	c.Description = field.NewString(table, "description")
	c.FactionID = field.NewInt32(table, "faction_id")
	c.HomeStationID = field.NewInt32(table, "home_station_id")
	c.MemberCount = field.NewInt32(table, "member_count")
	c.Name = field.NewString(table, "name")
	c.Shares = field.NewInt32(table, "shares")
	c.TaxRate = field.NewFloat64(table, "tax_rate")
	c.Ticker = field.NewString(table, "ticker")
	c.URL = field.NewString(table, "url")
	c.WarEligible = field.NewBool(table, "war_eligible")

	c.fillFieldMap()

	return c
}

func (c *corporation) WithContext(ctx context.Context) *corporationDo {
	return c.corporationDo.WithContext(ctx)
}

func (c corporation) TableName() string { return c.corporationDo.TableName() }

func (c corporation) Alias() string { return c.corporationDo.Alias() }

func (c corporation) Columns(cols ...field.Expr) gen.Columns { return c.corporationDo.Columns(cols...) }

func (c *corporation) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
	_f, ok := c.fieldMap[fieldName]
	if !ok || _f == nil {
		return nil, false
	}
	_oe, ok := _f.(field.OrderExpr)
	return _oe, ok
}

func (c *corporation) fillFieldMap() {
	c.fieldMap = make(map[string]field.Expr, 15)
	c.fieldMap["id"] = c.ID
	c.fieldMap["alliance_id"] = c.AllianceID
	c.fieldMap["ceo_id"] = c.CeoID
	c.fieldMap["creator_id"] = c.CreatorID
	c.fieldMap["date_founded"] = c.DateFounded
	c.fieldMap["description"] = c.Description
	c.fieldMap["faction_id"] = c.FactionID
	c.fieldMap["home_station_id"] = c.HomeStationID
	c.fieldMap["member_count"] = c.MemberCount
	c.fieldMap["name"] = c.Name
	c.fieldMap["shares"] = c.Shares
	c.fieldMap["tax_rate"] = c.TaxRate
	c.fieldMap["ticker"] = c.Ticker
	c.fieldMap["url"] = c.URL
	c.fieldMap["war_eligible"] = c.WarEligible
}

func (c corporation) clone(db *gorm.DB) corporation {
	c.corporationDo.ReplaceConnPool(db.Statement.ConnPool)
	return c
}

func (c corporation) replaceDB(db *gorm.DB) corporation {
	c.corporationDo.ReplaceDB(db)
	return c
}

type corporationDo struct{ gen.DO }

func (c corporationDo) Debug() *corporationDo {
	return c.withDO(c.DO.Debug())
}

func (c corporationDo) WithContext(ctx context.Context) *corporationDo {
	return c.withDO(c.DO.WithContext(ctx))
}

func (c corporationDo) ReadDB() *corporationDo {
	return c.Clauses(dbresolver.Read)
}

func (c corporationDo) WriteDB() *corporationDo {
	return c.Clauses(dbresolver.Write)
}

func (c corporationDo) Session(config *gorm.Session) *corporationDo {
	return c.withDO(c.DO.Session(config))
}

func (c corporationDo) Clauses(conds ...clause.Expression) *corporationDo {
	return c.withDO(c.DO.Clauses(conds...))
}

func (c corporationDo) Returning(value interface{}, columns ...string) *corporationDo {
	return c.withDO(c.DO.Returning(value, columns...))
}

func (c corporationDo) Not(conds ...gen.Condition) *corporationDo {
	return c.withDO(c.DO.Not(conds...))
}

func (c corporationDo) Or(conds ...gen.Condition) *corporationDo {
	return c.withDO(c.DO.Or(conds...))
}

func (c corporationDo) Select(conds ...field.Expr) *corporationDo {
	return c.withDO(c.DO.Select(conds...))
}

func (c corporationDo) Where(conds ...gen.Condition) *corporationDo {
	return c.withDO(c.DO.Where(conds...))
}

func (c corporationDo) Order(conds ...field.Expr) *corporationDo {
	return c.withDO(c.DO.Order(conds...))
}

func (c corporationDo) Distinct(cols ...field.Expr) *corporationDo {
	return c.withDO(c.DO.Distinct(cols...))
}

func (c corporationDo) Omit(cols ...field.Expr) *corporationDo {
	return c.withDO(c.DO.Omit(cols...))
}

func (c corporationDo) Join(table schema.Tabler, on ...field.Expr) *corporationDo {
	return c.withDO(c.DO.Join(table, on...))
}

func (c corporationDo) LeftJoin(table schema.Tabler, on ...field.Expr) *corporationDo {
	return c.withDO(c.DO.LeftJoin(table, on...))
}

func (c corporationDo) RightJoin(table schema.Tabler, on ...field.Expr) *corporationDo {
	return c.withDO(c.DO.RightJoin(table, on...))
}

func (c corporationDo) Group(cols ...field.Expr) *corporationDo {
	return c.withDO(c.DO.Group(cols...))
}

func (c corporationDo) Having(conds ...gen.Condition) *corporationDo {
	return c.withDO(c.DO.Having(conds...))
}

func (c corporationDo) Limit(limit int) *corporationDo {
	return c.withDO(c.DO.Limit(limit))
}

func (c corporationDo) Offset(offset int) *corporationDo {
	return c.withDO(c.DO.Offset(offset))
}

func (c corporationDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *corporationDo {
	return c.withDO(c.DO.Scopes(funcs...))
}

func (c corporationDo) Unscoped() *corporationDo {
	return c.withDO(c.DO.Unscoped())
}

func (c corporationDo) Create(values ...*model.Corporation) error {
	if len(values) == 0 {
		return nil
	}
	return c.DO.Create(values)
}

func (c corporationDo) CreateInBatches(values []*model.Corporation, batchSize int) error {
	return c.DO.CreateInBatches(values, batchSize)
}

// Save : !!! underlying implementation is different with GORM
// The method is equivalent to executing the statement: db.Clauses(clause.OnConflict{UpdateAll: true}).Create(values)
func (c corporationDo) Save(values ...*model.Corporation) error {
	if len(values) == 0 {
		return nil
	}
	return c.DO.Save(values)
}

func (c corporationDo) First() (*model.Corporation, error) {
	if result, err := c.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*model.Corporation), nil
	}
}

func (c corporationDo) Take() (*model.Corporation, error) {
	if result, err := c.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*model.Corporation), nil
	}
}

func (c corporationDo) Last() (*model.Corporation, error) {
	if result, err := c.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*model.Corporation), nil
	}
}

func (c corporationDo) Find() ([]*model.Corporation, error) {
	result, err := c.DO.Find()
	return result.([]*model.Corporation), err
}

func (c corporationDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Corporation, err error) {
	buf := make([]*model.Corporation, 0, batchSize)
	err = c.DO.FindInBatches(&buf, batchSize, func(tx gen.Dao, batch int) error {
		defer func() { results = append(results, buf...) }()
		return fc(tx, batch)
	})
	return results, err
}

func (c corporationDo) FindInBatches(result *[]*model.Corporation, batchSize int, fc func(tx gen.Dao, batch int) error) error {
	return c.DO.FindInBatches(result, batchSize, fc)
}

func (c corporationDo) Attrs(attrs ...field.AssignExpr) *corporationDo {
	return c.withDO(c.DO.Attrs(attrs...))
}

func (c corporationDo) Assign(attrs ...field.AssignExpr) *corporationDo {
	return c.withDO(c.DO.Assign(attrs...))
}

func (c corporationDo) Joins(fields ...field.RelationField) *corporationDo {
	for _, _f := range fields {
		c = *c.withDO(c.DO.Joins(_f))
	}
	return &c
}

func (c corporationDo) Preload(fields ...field.RelationField) *corporationDo {
	for _, _f := range fields {
		c = *c.withDO(c.DO.Preload(_f))
	}
	return &c
}

func (c corporationDo) FirstOrInit() (*model.Corporation, error) {
	if result, err := c.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*model.Corporation), nil
	}
}

func (c corporationDo) FirstOrCreate() (*model.Corporation, error) {
	if result, err := c.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*model.Corporation), nil
	}
}

func (c corporationDo) FindByPage(offset int, limit int) (result []*model.Corporation, count int64, err error) {
	result, err = c.Offset(offset).Limit(limit).Find()
	if err != nil {
		return
	}

	if size := len(result); 0 < limit && 0 < size && size < limit {
		count = int64(size + offset)
		return
	}

	count, err = c.Offset(-1).Limit(-1).Count()
	return
}

func (c corporationDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
	count, err = c.Count()
	if err != nil {
		return
	}

	err = c.Offset(offset).Limit(limit).Scan(result)
	return
}

func (c corporationDo) Scan(result interface{}) (err error) {
	return c.DO.Scan(result)
}

func (c corporationDo) Delete(models ...*model.Corporation) (result gen.ResultInfo, err error) {
	return c.DO.Delete(models)
}

func (c *corporationDo) withDO(do gen.Dao) *corporationDo {
	c.DO = *do.(*gen.DO)
	return c
}