template_event_log.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 model_gen

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/SelfDown/collect/model"
)

func newTemplateEventLog(db *gorm.DB, opts ...gen.DOOption) templateEventLog {
	_templateEventLog := templateEventLog{}

	_templateEventLog.templateEventLogDo.UseDB(db, opts...)
	_templateEventLog.templateEventLogDo.UseModel(&model.TemplateEventLog{})

	tableName := _templateEventLog.templateEventLogDo.TableName()
	_templateEventLog.ALL = field.NewAsterisk(tableName)
	_templateEventLog.TemplateEventLogID = field.NewString(tableName, "template_event_log_id")
	_templateEventLog.UserID = field.NewString(tableName, "user_id")
	_templateEventLog.EventID = field.NewString(tableName, "event_id")
	_templateEventLog.Msg = field.NewString(tableName, "msg")
	_templateEventLog.Datetime = field.NewString(tableName, "datetime")
	_templateEventLog.FromService = field.NewString(tableName, "from_service")

	_templateEventLog.fillFieldMap()

	return _templateEventLog
}

type templateEventLog struct {
	templateEventLogDo

	ALL                field.Asterisk
	TemplateEventLogID field.String
	UserID             field.String
	EventID            field.String
	Msg                field.String
	Datetime           field.String
	FromService        field.String

	fieldMap map[string]field.Expr
}

func (t templateEventLog) Table(newTableName string) *templateEventLog {
	t.templateEventLogDo.UseTable(newTableName)
	return t.updateTableName(newTableName)
}

func (t templateEventLog) As(alias string) *templateEventLog {
	t.templateEventLogDo.DO = *(t.templateEventLogDo.As(alias).(*gen.DO))
	return t.updateTableName(alias)
}

func (t *templateEventLog) updateTableName(table string) *templateEventLog {
	t.ALL = field.NewAsterisk(table)
	t.TemplateEventLogID = field.NewString(table, "template_event_log_id")
	t.UserID = field.NewString(table, "user_id")
	t.EventID = field.NewString(table, "event_id")
	t.Msg = field.NewString(table, "msg")
	t.Datetime = field.NewString(table, "datetime")
	t.FromService = field.NewString(table, "from_service")

	t.fillFieldMap()

	return t
}

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

func (t *templateEventLog) fillFieldMap() {
	t.fieldMap = make(map[string]field.Expr, 6)
	t.fieldMap["template_event_log_id"] = t.TemplateEventLogID
	t.fieldMap["user_id"] = t.UserID
	t.fieldMap["event_id"] = t.EventID
	t.fieldMap["msg"] = t.Msg
	t.fieldMap["datetime"] = t.Datetime
	t.fieldMap["from_service"] = t.FromService
}

func (t templateEventLog) clone(db *gorm.DB) templateEventLog {
	t.templateEventLogDo.ReplaceConnPool(db.Statement.ConnPool)
	return t
}

func (t templateEventLog) replaceDB(db *gorm.DB) templateEventLog {
	t.templateEventLogDo.ReplaceDB(db)
	return t
}

type templateEventLogDo struct{ gen.DO }

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

func (t templateEventLogDo) Debug() ITemplateEventLogDo {
	return t.withDO(t.DO.Debug())
}

func (t templateEventLogDo) WithContext(ctx context.Context) ITemplateEventLogDo {
	return t.withDO(t.DO.WithContext(ctx))
}

func (t templateEventLogDo) ReadDB() ITemplateEventLogDo {
	return t.Clauses(dbresolver.Read)
}

func (t templateEventLogDo) WriteDB() ITemplateEventLogDo {
	return t.Clauses(dbresolver.Write)
}

func (t templateEventLogDo) Session(config *gorm.Session) ITemplateEventLogDo {
	return t.withDO(t.DO.Session(config))
}

func (t templateEventLogDo) Clauses(conds ...clause.Expression) ITemplateEventLogDo {
	return t.withDO(t.DO.Clauses(conds...))
}

func (t templateEventLogDo) Returning(value interface{}, columns ...string) ITemplateEventLogDo {
	return t.withDO(t.DO.Returning(value, columns...))
}

func (t templateEventLogDo) Not(conds ...gen.Condition) ITemplateEventLogDo {
	return t.withDO(t.DO.Not(conds...))
}

func (t templateEventLogDo) Or(conds ...gen.Condition) ITemplateEventLogDo {
	return t.withDO(t.DO.Or(conds...))
}

func (t templateEventLogDo) Select(conds ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.Select(conds...))
}

func (t templateEventLogDo) Where(conds ...gen.Condition) ITemplateEventLogDo {
	return t.withDO(t.DO.Where(conds...))
}

func (t templateEventLogDo) Exists(subquery interface{ UnderlyingDB() *gorm.DB }) ITemplateEventLogDo {
	return t.Where(field.CompareSubQuery(field.ExistsOp, nil, subquery.UnderlyingDB()))
}

func (t templateEventLogDo) Order(conds ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.Order(conds...))
}

func (t templateEventLogDo) Distinct(cols ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.Distinct(cols...))
}

func (t templateEventLogDo) Omit(cols ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.Omit(cols...))
}

func (t templateEventLogDo) Join(table schema.Tabler, on ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.Join(table, on...))
}

func (t templateEventLogDo) LeftJoin(table schema.Tabler, on ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.LeftJoin(table, on...))
}

func (t templateEventLogDo) RightJoin(table schema.Tabler, on ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.RightJoin(table, on...))
}

func (t templateEventLogDo) Group(cols ...field.Expr) ITemplateEventLogDo {
	return t.withDO(t.DO.Group(cols...))
}

func (t templateEventLogDo) Having(conds ...gen.Condition) ITemplateEventLogDo {
	return t.withDO(t.DO.Having(conds...))
}

func (t templateEventLogDo) Limit(limit int) ITemplateEventLogDo {
	return t.withDO(t.DO.Limit(limit))
}

func (t templateEventLogDo) Offset(offset int) ITemplateEventLogDo {
	return t.withDO(t.DO.Offset(offset))
}

func (t templateEventLogDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ITemplateEventLogDo {
	return t.withDO(t.DO.Scopes(funcs...))
}

func (t templateEventLogDo) Unscoped() ITemplateEventLogDo {
	return t.withDO(t.DO.Unscoped())
}

func (t templateEventLogDo) Create(values ...*model.TemplateEventLog) error {
	if len(values) == 0 {
		return nil
	}
	return t.DO.Create(values)
}

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

func (t templateEventLogDo) First() (*model.TemplateEventLog, error) {
	if result, err := t.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*model.TemplateEventLog), nil
	}
}

func (t templateEventLogDo) Take() (*model.TemplateEventLog, error) {
	if result, err := t.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*model.TemplateEventLog), nil
	}
}

func (t templateEventLogDo) Last() (*model.TemplateEventLog, error) {
	if result, err := t.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*model.TemplateEventLog), nil
	}
}

func (t templateEventLogDo) Find() ([]*model.TemplateEventLog, error) {
	result, err := t.DO.Find()
	return result.([]*model.TemplateEventLog), err
}

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

func (t templateEventLogDo) Attrs(attrs ...field.AssignExpr) ITemplateEventLogDo {
	return t.withDO(t.DO.Attrs(attrs...))
}

func (t templateEventLogDo) Assign(attrs ...field.AssignExpr) ITemplateEventLogDo {
	return t.withDO(t.DO.Assign(attrs...))
}

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

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

func (t templateEventLogDo) FirstOrInit() (*model.TemplateEventLog, error) {
	if result, err := t.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*model.TemplateEventLog), nil
	}
}

func (t templateEventLogDo) FirstOrCreate() (*model.TemplateEventLog, error) {
	if result, err := t.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*model.TemplateEventLog), nil
	}
}

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

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

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

func (t templateEventLogDo) Scan(result interface{}) (err error) {
	return t.DO.Scan(result)
}

func (t templateEventLogDo) Delete(models ...*model.TemplateEventLog) (result gen.ResultInfo, err error) {
	return t.DO.Delete(models)
}

func (t *templateEventLogDo) withDO(do gen.Dao) *templateEventLogDo {
	t.DO = *do.(*gen.DO)
	return t
}