linstrom/storage-new/dbgen/remote_server_metadata.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 dbgen

import (
	"context"

	"git.mstar.dev/mstar/linstrom/storage-new/models"
	"gorm.io/gorm"
	"gorm.io/gorm/clause"
	"gorm.io/gorm/schema"

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

	"gorm.io/plugin/dbresolver"
)

func newRemoteServerMetadata(db *gorm.DB, opts ...gen.DOOption) remoteServerMetadata {
	_remoteServerMetadata := remoteServerMetadata{}

	_remoteServerMetadata.remoteServerMetadataDo.UseDB(db, opts...)
	_remoteServerMetadata.remoteServerMetadataDo.UseModel(&models.RemoteServerMetadata{})

	tableName := _remoteServerMetadata.remoteServerMetadataDo.TableName()
	_remoteServerMetadata.ALL = field.NewAsterisk(tableName)
	_remoteServerMetadata.ID = field.NewUint(tableName, "id")
	_remoteServerMetadata.CreatedAt = field.NewTime(tableName, "created_at")
	_remoteServerMetadata.UpdatedAt = field.NewTime(tableName, "updated_at")
	_remoteServerMetadata.DeletedAt = field.NewField(tableName, "deleted_at")
	_remoteServerMetadata.RemoteServerId = field.NewUint(tableName, "remote_server_id")
	_remoteServerMetadata.Key = field.NewString(tableName, "key")
	_remoteServerMetadata.Value = field.NewString(tableName, "value")
	_remoteServerMetadata.RemoteServer = remoteServerMetadataBelongsToRemoteServer{
		db: db.Session(&gorm.Session{}),

		RelationField: field.NewRelation("RemoteServer", "models.RemoteServer"),
		Icon: struct {
			field.RelationField
		}{
			RelationField: field.NewRelation("RemoteServer.Icon", "models.MediaMetadata"),
		},
		Metadata: struct {
			field.RelationField
			RemoteServer struct {
				field.RelationField
			}
		}{
			RelationField: field.NewRelation("RemoteServer.Metadata", "models.RemoteServerMetadata"),
			RemoteServer: struct {
				field.RelationField
			}{
				RelationField: field.NewRelation("RemoteServer.Metadata.RemoteServer", "models.RemoteServer"),
			},
		},
	}

	_remoteServerMetadata.fillFieldMap()

	return _remoteServerMetadata
}

type remoteServerMetadata struct {
	remoteServerMetadataDo

	ALL            field.Asterisk
	ID             field.Uint
	CreatedAt      field.Time
	UpdatedAt      field.Time
	DeletedAt      field.Field
	RemoteServerId field.Uint
	Key            field.String
	Value          field.String
	RemoteServer   remoteServerMetadataBelongsToRemoteServer

	fieldMap map[string]field.Expr
}

func (r remoteServerMetadata) Table(newTableName string) *remoteServerMetadata {
	r.remoteServerMetadataDo.UseTable(newTableName)
	return r.updateTableName(newTableName)
}

func (r remoteServerMetadata) As(alias string) *remoteServerMetadata {
	r.remoteServerMetadataDo.DO = *(r.remoteServerMetadataDo.As(alias).(*gen.DO))
	return r.updateTableName(alias)
}

func (r *remoteServerMetadata) updateTableName(table string) *remoteServerMetadata {
	r.ALL = field.NewAsterisk(table)
	r.ID = field.NewUint(table, "id")
	r.CreatedAt = field.NewTime(table, "created_at")
	r.UpdatedAt = field.NewTime(table, "updated_at")
	r.DeletedAt = field.NewField(table, "deleted_at")
	r.RemoteServerId = field.NewUint(table, "remote_server_id")
	r.Key = field.NewString(table, "key")
	r.Value = field.NewString(table, "value")

	r.fillFieldMap()

	return r
}

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

func (r *remoteServerMetadata) fillFieldMap() {
	r.fieldMap = make(map[string]field.Expr, 8)
	r.fieldMap["id"] = r.ID
	r.fieldMap["created_at"] = r.CreatedAt
	r.fieldMap["updated_at"] = r.UpdatedAt
	r.fieldMap["deleted_at"] = r.DeletedAt
	r.fieldMap["remote_server_id"] = r.RemoteServerId
	r.fieldMap["key"] = r.Key
	r.fieldMap["value"] = r.Value

}

func (r remoteServerMetadata) clone(db *gorm.DB) remoteServerMetadata {
	r.remoteServerMetadataDo.ReplaceConnPool(db.Statement.ConnPool)
	return r
}

func (r remoteServerMetadata) replaceDB(db *gorm.DB) remoteServerMetadata {
	r.remoteServerMetadataDo.ReplaceDB(db)
	return r
}

type remoteServerMetadataBelongsToRemoteServer struct {
	db *gorm.DB

	field.RelationField

	Icon struct {
		field.RelationField
	}
	Metadata struct {
		field.RelationField
		RemoteServer struct {
			field.RelationField
		}
	}
}

func (a remoteServerMetadataBelongsToRemoteServer) Where(conds ...field.Expr) *remoteServerMetadataBelongsToRemoteServer {
	if len(conds) == 0 {
		return &a
	}

	exprs := make([]clause.Expression, 0, len(conds))
	for _, cond := range conds {
		exprs = append(exprs, cond.BeCond().(clause.Expression))
	}
	a.db = a.db.Clauses(clause.Where{Exprs: exprs})
	return &a
}

func (a remoteServerMetadataBelongsToRemoteServer) WithContext(ctx context.Context) *remoteServerMetadataBelongsToRemoteServer {
	a.db = a.db.WithContext(ctx)
	return &a
}

func (a remoteServerMetadataBelongsToRemoteServer) Session(session *gorm.Session) *remoteServerMetadataBelongsToRemoteServer {
	a.db = a.db.Session(session)
	return &a
}

func (a remoteServerMetadataBelongsToRemoteServer) Model(m *models.RemoteServerMetadata) *remoteServerMetadataBelongsToRemoteServerTx {
	return &remoteServerMetadataBelongsToRemoteServerTx{a.db.Model(m).Association(a.Name())}
}

type remoteServerMetadataBelongsToRemoteServerTx struct{ tx *gorm.Association }

func (a remoteServerMetadataBelongsToRemoteServerTx) Find() (result *models.RemoteServer, err error) {
	return result, a.tx.Find(&result)
}

func (a remoteServerMetadataBelongsToRemoteServerTx) Append(values ...*models.RemoteServer) (err error) {
	targetValues := make([]interface{}, len(values))
	for i, v := range values {
		targetValues[i] = v
	}
	return a.tx.Append(targetValues...)
}

func (a remoteServerMetadataBelongsToRemoteServerTx) Replace(values ...*models.RemoteServer) (err error) {
	targetValues := make([]interface{}, len(values))
	for i, v := range values {
		targetValues[i] = v
	}
	return a.tx.Replace(targetValues...)
}

func (a remoteServerMetadataBelongsToRemoteServerTx) Delete(values ...*models.RemoteServer) (err error) {
	targetValues := make([]interface{}, len(values))
	for i, v := range values {
		targetValues[i] = v
	}
	return a.tx.Delete(targetValues...)
}

func (a remoteServerMetadataBelongsToRemoteServerTx) Clear() error {
	return a.tx.Clear()
}

func (a remoteServerMetadataBelongsToRemoteServerTx) Count() int64 {
	return a.tx.Count()
}

type remoteServerMetadataDo struct{ gen.DO }

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

func (r remoteServerMetadataDo) Debug() IRemoteServerMetadataDo {
	return r.withDO(r.DO.Debug())
}

func (r remoteServerMetadataDo) WithContext(ctx context.Context) IRemoteServerMetadataDo {
	return r.withDO(r.DO.WithContext(ctx))
}

func (r remoteServerMetadataDo) ReadDB() IRemoteServerMetadataDo {
	return r.Clauses(dbresolver.Read)
}

func (r remoteServerMetadataDo) WriteDB() IRemoteServerMetadataDo {
	return r.Clauses(dbresolver.Write)
}

func (r remoteServerMetadataDo) Session(config *gorm.Session) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Session(config))
}

func (r remoteServerMetadataDo) Clauses(conds ...clause.Expression) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Clauses(conds...))
}

func (r remoteServerMetadataDo) Returning(value interface{}, columns ...string) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Returning(value, columns...))
}

func (r remoteServerMetadataDo) Not(conds ...gen.Condition) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Not(conds...))
}

func (r remoteServerMetadataDo) Or(conds ...gen.Condition) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Or(conds...))
}

func (r remoteServerMetadataDo) Select(conds ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Select(conds...))
}

func (r remoteServerMetadataDo) Where(conds ...gen.Condition) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Where(conds...))
}

func (r remoteServerMetadataDo) Order(conds ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Order(conds...))
}

func (r remoteServerMetadataDo) Distinct(cols ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Distinct(cols...))
}

func (r remoteServerMetadataDo) Omit(cols ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Omit(cols...))
}

func (r remoteServerMetadataDo) Join(table schema.Tabler, on ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Join(table, on...))
}

func (r remoteServerMetadataDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.LeftJoin(table, on...))
}

func (r remoteServerMetadataDo) RightJoin(table schema.Tabler, on ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.RightJoin(table, on...))
}

func (r remoteServerMetadataDo) Group(cols ...field.Expr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Group(cols...))
}

func (r remoteServerMetadataDo) Having(conds ...gen.Condition) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Having(conds...))
}

func (r remoteServerMetadataDo) Limit(limit int) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Limit(limit))
}

func (r remoteServerMetadataDo) Offset(offset int) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Offset(offset))
}

func (r remoteServerMetadataDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Scopes(funcs...))
}

func (r remoteServerMetadataDo) Unscoped() IRemoteServerMetadataDo {
	return r.withDO(r.DO.Unscoped())
}

func (r remoteServerMetadataDo) Create(values ...*models.RemoteServerMetadata) error {
	if len(values) == 0 {
		return nil
	}
	return r.DO.Create(values)
}

func (r remoteServerMetadataDo) CreateInBatches(values []*models.RemoteServerMetadata, batchSize int) error {
	return r.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 (r remoteServerMetadataDo) Save(values ...*models.RemoteServerMetadata) error {
	if len(values) == 0 {
		return nil
	}
	return r.DO.Save(values)
}

func (r remoteServerMetadataDo) First() (*models.RemoteServerMetadata, error) {
	if result, err := r.DO.First(); err != nil {
		return nil, err
	} else {
		return result.(*models.RemoteServerMetadata), nil
	}
}

func (r remoteServerMetadataDo) Take() (*models.RemoteServerMetadata, error) {
	if result, err := r.DO.Take(); err != nil {
		return nil, err
	} else {
		return result.(*models.RemoteServerMetadata), nil
	}
}

func (r remoteServerMetadataDo) Last() (*models.RemoteServerMetadata, error) {
	if result, err := r.DO.Last(); err != nil {
		return nil, err
	} else {
		return result.(*models.RemoteServerMetadata), nil
	}
}

func (r remoteServerMetadataDo) Find() ([]*models.RemoteServerMetadata, error) {
	result, err := r.DO.Find()
	return result.([]*models.RemoteServerMetadata), err
}

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

func (r remoteServerMetadataDo) Attrs(attrs ...field.AssignExpr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Attrs(attrs...))
}

func (r remoteServerMetadataDo) Assign(attrs ...field.AssignExpr) IRemoteServerMetadataDo {
	return r.withDO(r.DO.Assign(attrs...))
}

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

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

func (r remoteServerMetadataDo) FirstOrInit() (*models.RemoteServerMetadata, error) {
	if result, err := r.DO.FirstOrInit(); err != nil {
		return nil, err
	} else {
		return result.(*models.RemoteServerMetadata), nil
	}
}

func (r remoteServerMetadataDo) FirstOrCreate() (*models.RemoteServerMetadata, error) {
	if result, err := r.DO.FirstOrCreate(); err != nil {
		return nil, err
	} else {
		return result.(*models.RemoteServerMetadata), nil
	}
}

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

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

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

func (r remoteServerMetadataDo) Scan(result interface{}) (err error) {
	return r.DO.Scan(result)
}

func (r remoteServerMetadataDo) Delete(models ...*models.RemoteServerMetadata) (result gen.ResultInfo, err error) {
	return r.DO.Delete(models)
}

func (r *remoteServerMetadataDo) withDO(do gen.Dao) *remoteServerMetadataDo {
	r.DO = *do.(*gen.DO)
	return r
}