// 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 dao

import (
	"context"

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

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

	"gorm.io/plugin/dbresolver"

	"git.rtzhtech.cn/iss/public-lib/model"
)

func newDevDevinfo(db *gorm.DB) devDevinfo {
	_devDevinfo := devDevinfo{}

	_devDevinfo.devDevinfoDo.UseDB(db)
	_devDevinfo.devDevinfoDo.UseModel(&model.DevDevinfo{})

	tableName := _devDevinfo.devDevinfoDo.TableName()
	_devDevinfo.ALL = field.NewField(tableName, "*")
	_devDevinfo.ID = field.NewInt32(tableName, "id")
	_devDevinfo.Stationid = field.NewInt32(tableName, "stationid")
	_devDevinfo.Deviceid = field.NewInt32(tableName, "deviceid")
	_devDevinfo.Devicename = field.NewString(tableName, "devicename")
	_devDevinfo.Appid = field.NewInt32(tableName, "appid")
	_devDevinfo.Modelid = field.NewInt32(tableName, "modelid")
	_devDevinfo.Protocol = field.NewString(tableName, "protocol")
	_devDevinfo.Serial = field.NewString(tableName, "serial")
	_devDevinfo.Baudrate = field.NewInt32(tableName, "baudrate")
	_devDevinfo.Stopbit = field.NewInt32(tableName, "stopbit")
	_devDevinfo.Checkbit = field.NewString(tableName, "checkbit")
	_devDevinfo.Databit = field.NewInt32(tableName, "databit")
	_devDevinfo.Slaveid = field.NewInt32(tableName, "slaveid")
	_devDevinfo.IP = field.NewString(tableName, "ip")
	_devDevinfo.Port = field.NewInt32(tableName, "port")
	_devDevinfo.Eid = field.NewString(tableName, "eid")
	_devDevinfo.Mqtttopic = field.NewString(tableName, "mqtttopic")
	_devDevinfo.Disable = field.NewInt32(tableName, "disable")
	_devDevinfo.Online = field.NewInt32(tableName, "online")
	_devDevinfo.CreateAt = field.NewTime(tableName, "create_at")
	_devDevinfo.UpdateAt = field.NewTime(tableName, "update_at")

	_devDevinfo.fillFieldMap()

	_devDevinfo.Base = newBase(tableName, db)

	return _devDevinfo
}

type devDevinfo struct {
	devDevinfoDo

	ALL        field.Field
	ID         field.Int32
	Stationid  field.Int32
	Deviceid   field.Int32
	Devicename field.String
	Appid      field.Int32
	Modelid    field.Int32
	Protocol   field.String
	Serial     field.String
	Baudrate   field.Int32
	Stopbit    field.Int32
	Checkbit   field.String
	Databit    field.Int32
	Slaveid    field.Int32
	IP         field.String
	Port       field.Int32
	Eid        field.String
	Mqtttopic  field.String
	Disable    field.Int32
	Online     field.Int32
	CreateAt   field.Time
	UpdateAt   field.Time

	fieldMap map[string]field.Expr
}

func (d devDevinfo) Table(newTableName string) *devDevinfo {
	d.devDevinfoDo.UseTable(newTableName)
	return d.updateTableName(newTableName)
}

func (d devDevinfo) As(alias string) *devDevinfo {
	d.devDevinfoDo.DO = *(d.devDevinfoDo.As(alias).(*gen.DO))
	return d.updateTableName(alias)
}

func (d *devDevinfo) updateTableName(table string) *devDevinfo {
	d.ALL = field.NewField(table, "*")
	d.ID = field.NewInt32(table, "id")
	d.Stationid = field.NewInt32(table, "stationid")
	d.Deviceid = field.NewInt32(table, "deviceid")
	d.Devicename = field.NewString(table, "devicename")
	d.Appid = field.NewInt32(table, "appid")
	d.Modelid = field.NewInt32(table, "modelid")
	d.Protocol = field.NewString(table, "protocol")
	d.Serial = field.NewString(table, "serial")
	d.Baudrate = field.NewInt32(table, "baudrate")
	d.Stopbit = field.NewInt32(table, "stopbit")
	d.Checkbit = field.NewString(table, "checkbit")
	d.Databit = field.NewInt32(table, "databit")
	d.Slaveid = field.NewInt32(table, "slaveid")
	d.IP = field.NewString(table, "ip")
	d.Port = field.NewInt32(table, "port")
	d.Eid = field.NewString(table, "eid")
	d.Mqtttopic = field.NewString(table, "mqtttopic")
	d.Disable = field.NewInt32(table, "disable")
	d.Online = field.NewInt32(table, "online")
	d.CreateAt = field.NewTime(table, "create_at")
	d.UpdateAt = field.NewTime(table, "update_at")

	d.fillFieldMap()

	return d
}

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

func (d *devDevinfo) fillFieldMap() {
	d.fieldMap = make(map[string]field.Expr, 21)
	d.fieldMap["id"] = d.ID
	d.fieldMap["stationid"] = d.Stationid
	d.fieldMap["deviceid"] = d.Deviceid
	d.fieldMap["devicename"] = d.Devicename
	d.fieldMap["appid"] = d.Appid
	d.fieldMap["modelid"] = d.Modelid
	d.fieldMap["protocol"] = d.Protocol
	d.fieldMap["serial"] = d.Serial
	d.fieldMap["baudrate"] = d.Baudrate
	d.fieldMap["stopbit"] = d.Stopbit
	d.fieldMap["checkbit"] = d.Checkbit
	d.fieldMap["databit"] = d.Databit
	d.fieldMap["slaveid"] = d.Slaveid
	d.fieldMap["ip"] = d.IP
	d.fieldMap["port"] = d.Port
	d.fieldMap["eid"] = d.Eid
	d.fieldMap["mqtttopic"] = d.Mqtttopic
	d.fieldMap["disable"] = d.Disable
	d.fieldMap["online"] = d.Online
	d.fieldMap["create_at"] = d.CreateAt
	d.fieldMap["update_at"] = d.UpdateAt
}

func (d devDevinfo) clone(db *gorm.DB) devDevinfo {
	d.devDevinfoDo.ReplaceDB(db)
	return d
}

type devDevinfoDo struct {
	gen.DO
	Base *Base
}

func (d devDevinfoDo) Debug() *devDevinfoDo {
	return d.withDO(d.DO.Debug())
}

func (d devDevinfoDo) WithContext(ctx context.Context) *devDevinfoDo {
	return d.withDO(d.DO.WithContext(ctx))
}

func (d devDevinfoDo) ReadDB() *devDevinfoDo {
	return d.Clauses(dbresolver.Read)
}

func (d devDevinfoDo) WriteDB() *devDevinfoDo {
	return d.Clauses(dbresolver.Write)
}

func (d devDevinfoDo) Clauses(conds ...clause.Expression) *devDevinfoDo {
	return d.withDO(d.DO.Clauses(conds...))
}

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

func (d devDevinfoDo) Not(conds ...gen.Condition) *devDevinfoDo {
	return d.withDO(d.DO.Not(conds...))
}

func (d devDevinfoDo) Or(conds ...gen.Condition) *devDevinfoDo {
	return d.withDO(d.DO.Or(conds...))
}

func (d devDevinfoDo) Select(conds ...field.Expr) *devDevinfoDo {
	return d.withDO(d.DO.Select(conds...))
}

func (d devDevinfoDo) Where(conds ...gen.Condition) *devDevinfoDo {
	return d.withDO(d.DO.Where(conds...))
}

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

func (d devDevinfoDo) Order(conds ...field.Expr) *devDevinfoDo {
	return d.withDO(d.DO.Order(conds...))
}

func (d devDevinfoDo) Distinct(cols ...field.Expr) *devDevinfoDo {
	return d.withDO(d.DO.Distinct(cols...))
}

func (d devDevinfoDo) Omit(cols ...field.Expr) *devDevinfoDo {
	return d.withDO(d.DO.Omit(cols...))
}

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

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

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

func (d devDevinfoDo) Group(cols ...field.Expr) *devDevinfoDo {
	return d.withDO(d.DO.Group(cols...))
}

func (d devDevinfoDo) Having(conds ...gen.Condition) *devDevinfoDo {
	return d.withDO(d.DO.Having(conds...))
}

func (d devDevinfoDo) Limit(limit int) *devDevinfoDo {
	return d.withDO(d.DO.Limit(limit))
}

func (d devDevinfoDo) Offset(offset int) *devDevinfoDo {
	return d.withDO(d.DO.Offset(offset))
}

func (d devDevinfoDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *devDevinfoDo {
	return d.withDO(d.DO.Scopes(funcs...))
}

func (d devDevinfoDo) Unscoped() *devDevinfoDo {
	return d.withDO(d.DO.Unscoped())
}

func (d devDevinfoDo) Create(values ...*model.DevDevinfo) error {
	if len(values) == 0 {
		return nil
	}
	return d.DO.Create(values)
}

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

func (d devDevinfoDo) First() (*model.DevDevinfo, error) {
	if result, err := d.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*model.DevDevinfo), nil
	}
}

func (d devDevinfoDo) Take() (*model.DevDevinfo, error) {
	if result, err := d.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*model.DevDevinfo), nil
	}
}

func (d devDevinfoDo) Last() (*model.DevDevinfo, error) {
	if result, err := d.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*model.DevDevinfo), nil
	}
}

func (d devDevinfoDo) Find() ([]*model.DevDevinfo, error) {
	result, err := d.DO.Find()
	return result.([]*model.DevDevinfo), err
}

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

func (d devDevinfoDo) Attrs(attrs ...field.AssignExpr) *devDevinfoDo {
	return d.withDO(d.DO.Attrs(attrs...))
}

func (d devDevinfoDo) Assign(attrs ...field.AssignExpr) *devDevinfoDo {
	return d.withDO(d.DO.Assign(attrs...))
}

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

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

func (d devDevinfoDo) FirstOrInit() (*model.DevDevinfo, error) {
	if result, err := d.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*model.DevDevinfo), nil
	}
}

func (d devDevinfoDo) FirstOrCreate() (*model.DevDevinfo, error) {
	if result, err := d.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*model.DevDevinfo), nil
	}
}

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

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

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

func (d devDevinfoDo) Scan(result interface{}) (err error) {
	return d.DO.Scan(result)
}

func (d devDevinfoDo) Delete(models ...*model.DevDevinfo) (result gen.ResultInfo, err error) {
	return d.DO.Delete(models)
}

func (d *devDevinfoDo) withDO(do gen.Dao) *devDevinfoDo {
	d.DO = *do.(*gen.DO)
	return d
}