youtu_server/gorm-gen/dao/query/app_user.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 query

import (
	"context"

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

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

	"gorm.io/plugin/dbresolver"

	"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model"
)

func newAppUser(db *gorm.DB, opts ...gen.DOOption) appUser {
	_appUser := appUser{}

	_appUser.appUserDo.UseDB(db, opts...)
	_appUser.appUserDo.UseModel(&model.AppUser{})

	tableName := _appUser.appUserDo.TableName()
	_appUser.ALL = field.NewAsterisk(tableName)
	_appUser.ID = field.NewUint64(tableName, "id")
	_appUser.AppAccountID = field.NewUint32(tableName, "app_account_id")
	_appUser.Openid = field.NewString(tableName, "openid")
	_appUser.Unionid = field.NewString(tableName, "unionid")
	_appUser.Nickname = field.NewString(tableName, "nickname")
	_appUser.Avatar = field.NewString(tableName, "avatar")
	_appUser.AnonymousOpenid = field.NewString(tableName, "anonymous_openid")
	_appUser.CreatedAt = field.NewTime(tableName, "created_at")
	_appUser.UpdatedAt = field.NewTime(tableName, "updated_at")

	_appUser.fillFieldMap()

	return _appUser
}

type appUser struct {
	appUserDo

	ALL             field.Asterisk
	ID              field.Uint64
	AppAccountID    field.Uint32
	Openid          field.String
	Unionid         field.String
	Nickname        field.String
	Avatar          field.String
	AnonymousOpenid field.String
	CreatedAt       field.Time
	UpdatedAt       field.Time

	fieldMap map[string]field.Expr
}

func (a appUser) Table(newTableName string) *appUser {
	a.appUserDo.UseTable(newTableName)
	return a.updateTableName(newTableName)
}

func (a appUser) As(alias string) *appUser {
	a.appUserDo.DO = *(a.appUserDo.As(alias).(*gen.DO))
	return a.updateTableName(alias)
}

func (a *appUser) updateTableName(table string) *appUser {
	a.ALL = field.NewAsterisk(table)
	a.ID = field.NewUint64(table, "id")
	a.AppAccountID = field.NewUint32(table, "app_account_id")
	a.Openid = field.NewString(table, "openid")
	a.Unionid = field.NewString(table, "unionid")
	a.Nickname = field.NewString(table, "nickname")
	a.Avatar = field.NewString(table, "avatar")
	a.AnonymousOpenid = field.NewString(table, "anonymous_openid")
	a.CreatedAt = field.NewTime(table, "created_at")
	a.UpdatedAt = field.NewTime(table, "updated_at")

	a.fillFieldMap()

	return a
}

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

func (a *appUser) fillFieldMap() {
	a.fieldMap = make(map[string]field.Expr, 9)
	a.fieldMap["id"] = a.ID
	a.fieldMap["app_account_id"] = a.AppAccountID
	a.fieldMap["openid"] = a.Openid
	a.fieldMap["unionid"] = a.Unionid
	a.fieldMap["nickname"] = a.Nickname
	a.fieldMap["avatar"] = a.Avatar
	a.fieldMap["anonymous_openid"] = a.AnonymousOpenid
	a.fieldMap["created_at"] = a.CreatedAt
	a.fieldMap["updated_at"] = a.UpdatedAt
}

func (a appUser) clone(db *gorm.DB) appUser {
	a.appUserDo.ReplaceConnPool(db.Statement.ConnPool)
	return a
}

func (a appUser) replaceDB(db *gorm.DB) appUser {
	a.appUserDo.ReplaceDB(db)
	return a
}

type appUserDo struct{ gen.DO }

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

func (a appUserDo) Debug() IAppUserDo {
	return a.withDO(a.DO.Debug())
}

func (a appUserDo) WithContext(ctx context.Context) IAppUserDo {
	return a.withDO(a.DO.WithContext(ctx))
}

func (a appUserDo) ReadDB() IAppUserDo {
	return a.Clauses(dbresolver.Read)
}

func (a appUserDo) WriteDB() IAppUserDo {
	return a.Clauses(dbresolver.Write)
}

func (a appUserDo) Session(config *gorm.Session) IAppUserDo {
	return a.withDO(a.DO.Session(config))
}

func (a appUserDo) Clauses(conds ...clause.Expression) IAppUserDo {
	return a.withDO(a.DO.Clauses(conds...))
}

func (a appUserDo) Returning(value interface{}, columns ...string) IAppUserDo {
	return a.withDO(a.DO.Returning(value, columns...))
}

func (a appUserDo) Not(conds ...gen.Condition) IAppUserDo {
	return a.withDO(a.DO.Not(conds...))
}

func (a appUserDo) Or(conds ...gen.Condition) IAppUserDo {
	return a.withDO(a.DO.Or(conds...))
}

func (a appUserDo) Select(conds ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.Select(conds...))
}

func (a appUserDo) Where(conds ...gen.Condition) IAppUserDo {
	return a.withDO(a.DO.Where(conds...))
}

func (a appUserDo) Order(conds ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.Order(conds...))
}

func (a appUserDo) Distinct(cols ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.Distinct(cols...))
}

func (a appUserDo) Omit(cols ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.Omit(cols...))
}

func (a appUserDo) Join(table schema.Tabler, on ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.Join(table, on...))
}

func (a appUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.LeftJoin(table, on...))
}

func (a appUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.RightJoin(table, on...))
}

func (a appUserDo) Group(cols ...field.Expr) IAppUserDo {
	return a.withDO(a.DO.Group(cols...))
}

func (a appUserDo) Having(conds ...gen.Condition) IAppUserDo {
	return a.withDO(a.DO.Having(conds...))
}

func (a appUserDo) Limit(limit int) IAppUserDo {
	return a.withDO(a.DO.Limit(limit))
}

func (a appUserDo) Offset(offset int) IAppUserDo {
	return a.withDO(a.DO.Offset(offset))
}

func (a appUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAppUserDo {
	return a.withDO(a.DO.Scopes(funcs...))
}

func (a appUserDo) Unscoped() IAppUserDo {
	return a.withDO(a.DO.Unscoped())
}

func (a appUserDo) Create(values ...*model.AppUser) error {
	if len(values) == 0 {
		return nil
	}
	return a.DO.Create(values)
}

func (a appUserDo) CreateInBatches(values []*model.AppUser, batchSize int) error {
	return a.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 (a appUserDo) Save(values ...*model.AppUser) error {
	if len(values) == 0 {
		return nil
	}
	return a.DO.Save(values)
}

func (a appUserDo) First() (*model.AppUser, error) {
	if result, err := a.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*model.AppUser), nil
	}
}

func (a appUserDo) Take() (*model.AppUser, error) {
	if result, err := a.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*model.AppUser), nil
	}
}

func (a appUserDo) Last() (*model.AppUser, error) {
	if result, err := a.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*model.AppUser), nil
	}
}

func (a appUserDo) Find() ([]*model.AppUser, error) {
	result, err := a.DO.Find()
	return result.([]*model.AppUser), err
}

func (a appUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppUser, err error) {
	buf := make([]*model.AppUser, 0, batchSize)
	err = a.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 (a appUserDo) FindInBatches(result *[]*model.AppUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
	return a.DO.FindInBatches(result, batchSize, fc)
}

func (a appUserDo) Attrs(attrs ...field.AssignExpr) IAppUserDo {
	return a.withDO(a.DO.Attrs(attrs...))
}

func (a appUserDo) Assign(attrs ...field.AssignExpr) IAppUserDo {
	return a.withDO(a.DO.Assign(attrs...))
}

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

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

func (a appUserDo) FirstOrInit() (*model.AppUser, error) {
	if result, err := a.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*model.AppUser), nil
	}
}

func (a appUserDo) FirstOrCreate() (*model.AppUser, error) {
	if result, err := a.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*model.AppUser), nil
	}
}

func (a appUserDo) FindByPage(offset int, limit int) (result []*model.AppUser, count int64, err error) {
	result, err = a.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 = a.Offset(-1).Limit(-1).Count()
	return
}

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

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

func (a appUserDo) Scan(result interface{}) (err error) {
	return a.DO.Scan(result)
}

func (a appUserDo) Delete(models ...*model.AppUser) (result gen.ResultInfo, err error) {
	return a.DO.Delete(models)
}

func (a *appUserDo) withDO(do gen.Dao) *appUserDo {
	a.DO = *do.(*gen.DO)
	return a
}