Initial commit.

query/ansprechpartners.gen.go

@@ -0,0 +1,562 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) ansprechpartner {
+	_ansprechpartner := ansprechpartner{}
+
+	_ansprechpartner.ansprechpartnerDo.UseDB(db, opts...)
+	_ansprechpartner.ansprechpartnerDo.UseModel(&model.Ansprechpartner{})
+
+	tableName := _ansprechpartner.ansprechpartnerDo.TableName()
+	_ansprechpartner.ALL = field.NewAsterisk(tableName)
+	_ansprechpartner.ID = field.NewUint(tableName, "id")
+	_ansprechpartner.CreatedAt = field.NewTime(tableName, "created_at")
+	_ansprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_ansprechpartner.DeletedAt = field.NewField(tableName, "deleted_at")
+	_ansprechpartner.ImageURL = field.NewString(tableName, "image_url")
+	_ansprechpartner.Title = field.NewString(tableName, "title")
+	_ansprechpartner.FirstName = field.NewString(tableName, "first_name")
+	_ansprechpartner.LastName = field.NewString(tableName, "last_name")
+	_ansprechpartner.LastTitle = field.NewString(tableName, "last_title")
+	_ansprechpartner.EMail = field.NewString(tableName, "e_mail")
+	_ansprechpartner.Phone = field.NewString(tableName, "phone")
+	_ansprechpartner.Mobile = field.NewString(tableName, "mobile")
+	_ansprechpartner.Notes = field.NewString(tableName, "notes")
+	_ansprechpartner.Description = field.NewString(tableName, "description")
+	_ansprechpartner.Active = field.NewBool(tableName, "active")
+	_ansprechpartner.Gender = field.NewInt(tableName, "gender")
+	_ansprechpartner.Firmen = ansprechpartnerManyToManyFirmen{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Firmen", "model.Firma"),
+		Tochergesellschaften: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Firmen.Tochergesellschaften", "model.Firma"),
+		},
+		Ansprechpartner: struct {
+			field.RelationField
+			Firmen struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Firmen.Ansprechpartner", "model.Ansprechpartner"),
+			Firmen: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Firmen.Ansprechpartner.Firmen", "model.Firma"),
+			},
+		},
+	}
+
+	_ansprechpartner.fillFieldMap()
+
+	return _ansprechpartner
+}
+
+type ansprechpartner struct {
+	ansprechpartnerDo
+
+	ALL         field.Asterisk
+	ID          field.Uint
+	CreatedAt   field.Time
+	UpdatedAt   field.Time
+	DeletedAt   field.Field
+	ImageURL    field.String
+	Title       field.String
+	FirstName   field.String
+	LastName    field.String
+	LastTitle   field.String
+	EMail       field.String
+	Phone       field.String
+	Mobile      field.String
+	Notes       field.String
+	Description field.String
+	Active      field.Bool
+	Gender      field.Int
+	Firmen      ansprechpartnerManyToManyFirmen
+
+	fieldMap map[string]field.Expr
+}
+
+func (a ansprechpartner) Table(newTableName string) *ansprechpartner {
+	a.ansprechpartnerDo.UseTable(newTableName)
+	return a.updateTableName(newTableName)
+}
+
+func (a ansprechpartner) As(alias string) *ansprechpartner {
+	a.ansprechpartnerDo.DO = *(a.ansprechpartnerDo.As(alias).(*gen.DO))
+	return a.updateTableName(alias)
+}
+
+func (a *ansprechpartner) updateTableName(table string) *ansprechpartner {
+	a.ALL = field.NewAsterisk(table)
+	a.ID = field.NewUint(table, "id")
+	a.CreatedAt = field.NewTime(table, "created_at")
+	a.UpdatedAt = field.NewTime(table, "updated_at")
+	a.DeletedAt = field.NewField(table, "deleted_at")
+	a.ImageURL = field.NewString(table, "image_url")
+	a.Title = field.NewString(table, "title")
+	a.FirstName = field.NewString(table, "first_name")
+	a.LastName = field.NewString(table, "last_name")
+	a.LastTitle = field.NewString(table, "last_title")
+	a.EMail = field.NewString(table, "e_mail")
+	a.Phone = field.NewString(table, "phone")
+	a.Mobile = field.NewString(table, "mobile")
+	a.Notes = field.NewString(table, "notes")
+	a.Description = field.NewString(table, "description")
+	a.Active = field.NewBool(table, "active")
+	a.Gender = field.NewInt(table, "gender")
+
+	a.fillFieldMap()
+
+	return a
+}
+
+func (a *ansprechpartner) 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 *ansprechpartner) fillFieldMap() {
+	a.fieldMap = make(map[string]field.Expr, 17)
+	a.fieldMap["id"] = a.ID
+	a.fieldMap["created_at"] = a.CreatedAt
+	a.fieldMap["updated_at"] = a.UpdatedAt
+	a.fieldMap["deleted_at"] = a.DeletedAt
+	a.fieldMap["image_url"] = a.ImageURL
+	a.fieldMap["title"] = a.Title
+	a.fieldMap["first_name"] = a.FirstName
+	a.fieldMap["last_name"] = a.LastName
+	a.fieldMap["last_title"] = a.LastTitle
+	a.fieldMap["e_mail"] = a.EMail
+	a.fieldMap["phone"] = a.Phone
+	a.fieldMap["mobile"] = a.Mobile
+	a.fieldMap["notes"] = a.Notes
+	a.fieldMap["description"] = a.Description
+	a.fieldMap["active"] = a.Active
+	a.fieldMap["gender"] = a.Gender
+
+}
+
+func (a ansprechpartner) clone(db *gorm.DB) ansprechpartner {
+	a.ansprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool)
+	a.Firmen.db = db.Session(&gorm.Session{Initialized: true})
+	a.Firmen.db.Statement.ConnPool = db.Statement.ConnPool
+	return a
+}
+
+func (a ansprechpartner) replaceDB(db *gorm.DB) ansprechpartner {
+	a.ansprechpartnerDo.ReplaceDB(db)
+	a.Firmen.db = db.Session(&gorm.Session{})
+	return a
+}
+
+type ansprechpartnerManyToManyFirmen struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Tochergesellschaften struct {
+		field.RelationField
+	}
+	Ansprechpartner struct {
+		field.RelationField
+		Firmen struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a ansprechpartnerManyToManyFirmen) Where(conds ...field.Expr) *ansprechpartnerManyToManyFirmen {
+	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 ansprechpartnerManyToManyFirmen) WithContext(ctx context.Context) *ansprechpartnerManyToManyFirmen {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a ansprechpartnerManyToManyFirmen) Session(session *gorm.Session) *ansprechpartnerManyToManyFirmen {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a ansprechpartnerManyToManyFirmen) Model(m *model.Ansprechpartner) *ansprechpartnerManyToManyFirmenTx {
+	return &ansprechpartnerManyToManyFirmenTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a ansprechpartnerManyToManyFirmen) Unscoped() *ansprechpartnerManyToManyFirmen {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type ansprechpartnerManyToManyFirmenTx struct{ tx *gorm.Association }
+
+func (a ansprechpartnerManyToManyFirmenTx) Find() (result []*model.Firma, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a ansprechpartnerManyToManyFirmenTx) Append(values ...*model.Firma) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a ansprechpartnerManyToManyFirmenTx) Replace(values ...*model.Firma) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a ansprechpartnerManyToManyFirmenTx) Delete(values ...*model.Firma) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a ansprechpartnerManyToManyFirmenTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a ansprechpartnerManyToManyFirmenTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a ansprechpartnerManyToManyFirmenTx) Unscoped() *ansprechpartnerManyToManyFirmenTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type ansprechpartnerDo struct{ gen.DO }
+
+type IAnsprechpartnerDo interface {
+	gen.SubQuery
+	Debug() IAnsprechpartnerDo
+	WithContext(ctx context.Context) IAnsprechpartnerDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IAnsprechpartnerDo
+	WriteDB() IAnsprechpartnerDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IAnsprechpartnerDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IAnsprechpartnerDo
+	Not(conds ...gen.Condition) IAnsprechpartnerDo
+	Or(conds ...gen.Condition) IAnsprechpartnerDo
+	Select(conds ...field.Expr) IAnsprechpartnerDo
+	Where(conds ...gen.Condition) IAnsprechpartnerDo
+	Order(conds ...field.Expr) IAnsprechpartnerDo
+	Distinct(cols ...field.Expr) IAnsprechpartnerDo
+	Omit(cols ...field.Expr) IAnsprechpartnerDo
+	Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo
+	Group(cols ...field.Expr) IAnsprechpartnerDo
+	Having(conds ...gen.Condition) IAnsprechpartnerDo
+	Limit(limit int) IAnsprechpartnerDo
+	Offset(offset int) IAnsprechpartnerDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo
+	Unscoped() IAnsprechpartnerDo
+	Create(values ...*model.Ansprechpartner) error
+	CreateInBatches(values []*model.Ansprechpartner, batchSize int) error
+	Save(values ...*model.Ansprechpartner) error
+	First() (*model.Ansprechpartner, error)
+	Take() (*model.Ansprechpartner, error)
+	Last() (*model.Ansprechpartner, error)
+	Find() ([]*model.Ansprechpartner, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error)
+	FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Ansprechpartner) (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) IAnsprechpartnerDo
+	Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo
+	Joins(fields ...field.RelationField) IAnsprechpartnerDo
+	Preload(fields ...field.RelationField) IAnsprechpartnerDo
+	FirstOrInit() (*model.Ansprechpartner, error)
+	FirstOrCreate() (*model.Ansprechpartner, error)
+	FindByPage(offset int, limit int) (result []*model.Ansprechpartner, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IAnsprechpartnerDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (a ansprechpartnerDo) Debug() IAnsprechpartnerDo {
+	return a.withDO(a.DO.Debug())
+}
+
+func (a ansprechpartnerDo) WithContext(ctx context.Context) IAnsprechpartnerDo {
+	return a.withDO(a.DO.WithContext(ctx))
+}
+
+func (a ansprechpartnerDo) ReadDB() IAnsprechpartnerDo {
+	return a.Clauses(dbresolver.Read)
+}
+
+func (a ansprechpartnerDo) WriteDB() IAnsprechpartnerDo {
+	return a.Clauses(dbresolver.Write)
+}
+
+func (a ansprechpartnerDo) Session(config *gorm.Session) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Session(config))
+}
+
+func (a ansprechpartnerDo) Clauses(conds ...clause.Expression) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Clauses(conds...))
+}
+
+func (a ansprechpartnerDo) Returning(value interface{}, columns ...string) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Returning(value, columns...))
+}
+
+func (a ansprechpartnerDo) Not(conds ...gen.Condition) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Not(conds...))
+}
+
+func (a ansprechpartnerDo) Or(conds ...gen.Condition) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Or(conds...))
+}
+
+func (a ansprechpartnerDo) Select(conds ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Select(conds...))
+}
+
+func (a ansprechpartnerDo) Where(conds ...gen.Condition) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Where(conds...))
+}
+
+func (a ansprechpartnerDo) Order(conds ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Order(conds...))
+}
+
+func (a ansprechpartnerDo) Distinct(cols ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Distinct(cols...))
+}
+
+func (a ansprechpartnerDo) Omit(cols ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Omit(cols...))
+}
+
+func (a ansprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Join(table, on...))
+}
+
+func (a ansprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.LeftJoin(table, on...))
+}
+
+func (a ansprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.RightJoin(table, on...))
+}
+
+func (a ansprechpartnerDo) Group(cols ...field.Expr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Group(cols...))
+}
+
+func (a ansprechpartnerDo) Having(conds ...gen.Condition) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Having(conds...))
+}
+
+func (a ansprechpartnerDo) Limit(limit int) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Limit(limit))
+}
+
+func (a ansprechpartnerDo) Offset(offset int) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Offset(offset))
+}
+
+func (a ansprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Scopes(funcs...))
+}
+
+func (a ansprechpartnerDo) Unscoped() IAnsprechpartnerDo {
+	return a.withDO(a.DO.Unscoped())
+}
+
+func (a ansprechpartnerDo) Create(values ...*model.Ansprechpartner) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Create(values)
+}
+
+func (a ansprechpartnerDo) CreateInBatches(values []*model.Ansprechpartner, 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 ansprechpartnerDo) Save(values ...*model.Ansprechpartner) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return a.DO.Save(values)
+}
+
+func (a ansprechpartnerDo) First() (*model.Ansprechpartner, error) {
+	if result, err := a.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Ansprechpartner), nil
+	}
+}
+
+func (a ansprechpartnerDo) Take() (*model.Ansprechpartner, error) {
+	if result, err := a.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Ansprechpartner), nil
+	}
+}
+
+func (a ansprechpartnerDo) Last() (*model.Ansprechpartner, error) {
+	if result, err := a.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Ansprechpartner), nil
+	}
+}
+
+func (a ansprechpartnerDo) Find() ([]*model.Ansprechpartner, error) {
+	result, err := a.DO.Find()
+	return result.([]*model.Ansprechpartner), err
+}
+
+func (a ansprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Ansprechpartner, err error) {
+	buf := make([]*model.Ansprechpartner, 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 ansprechpartnerDo) FindInBatches(result *[]*model.Ansprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return a.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (a ansprechpartnerDo) Attrs(attrs ...field.AssignExpr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Attrs(attrs...))
+}
+
+func (a ansprechpartnerDo) Assign(attrs ...field.AssignExpr) IAnsprechpartnerDo {
+	return a.withDO(a.DO.Assign(attrs...))
+}
+
+func (a ansprechpartnerDo) Joins(fields ...field.RelationField) IAnsprechpartnerDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Joins(_f))
+	}
+	return &a
+}
+
+func (a ansprechpartnerDo) Preload(fields ...field.RelationField) IAnsprechpartnerDo {
+	for _, _f := range fields {
+		a = *a.withDO(a.DO.Preload(_f))
+	}
+	return &a
+}
+
+func (a ansprechpartnerDo) FirstOrInit() (*model.Ansprechpartner, error) {
+	if result, err := a.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Ansprechpartner), nil
+	}
+}
+
+func (a ansprechpartnerDo) FirstOrCreate() (*model.Ansprechpartner, error) {
+	if result, err := a.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Ansprechpartner), nil
+	}
+}
+
+func (a ansprechpartnerDo) FindByPage(offset int, limit int) (result []*model.Ansprechpartner, 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 ansprechpartnerDo) 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 ansprechpartnerDo) Scan(result interface{}) (err error) {
+	return a.DO.Scan(result)
+}
+
+func (a ansprechpartnerDo) Delete(models ...*model.Ansprechpartner) (result gen.ResultInfo, err error) {
+	return a.DO.Delete(models)
+}
+
+func (a *ansprechpartnerDo) withDO(do gen.Dao) *ansprechpartnerDo {
+	a.DO = *do.(*gen.DO)
+	return a
+}

query/dokuments.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newDokument(db *gorm.DB, opts ...gen.DOOption) dokument {
+	_dokument := dokument{}
+
+	_dokument.dokumentDo.UseDB(db, opts...)
+	_dokument.dokumentDo.UseModel(&model.Dokument{})
+
+	tableName := _dokument.dokumentDo.TableName()
+	_dokument.ALL = field.NewAsterisk(tableName)
+	_dokument.ID = field.NewUint(tableName, "id")
+	_dokument.CreatedAt = field.NewTime(tableName, "created_at")
+	_dokument.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_dokument.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_dokument.fillFieldMap()
+
+	return _dokument
+}
+
+type dokument struct {
+	dokumentDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (d dokument) Table(newTableName string) *dokument {
+	d.dokumentDo.UseTable(newTableName)
+	return d.updateTableName(newTableName)
+}
+
+func (d dokument) As(alias string) *dokument {
+	d.dokumentDo.DO = *(d.dokumentDo.As(alias).(*gen.DO))
+	return d.updateTableName(alias)
+}
+
+func (d *dokument) updateTableName(table string) *dokument {
+	d.ALL = field.NewAsterisk(table)
+	d.ID = field.NewUint(table, "id")
+	d.CreatedAt = field.NewTime(table, "created_at")
+	d.UpdatedAt = field.NewTime(table, "updated_at")
+	d.DeletedAt = field.NewField(table, "deleted_at")
+
+	d.fillFieldMap()
+
+	return d
+}
+
+func (d *dokument) 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 *dokument) fillFieldMap() {
+	d.fieldMap = make(map[string]field.Expr, 4)
+	d.fieldMap["id"] = d.ID
+	d.fieldMap["created_at"] = d.CreatedAt
+	d.fieldMap["updated_at"] = d.UpdatedAt
+	d.fieldMap["deleted_at"] = d.DeletedAt
+}
+
+func (d dokument) clone(db *gorm.DB) dokument {
+	d.dokumentDo.ReplaceConnPool(db.Statement.ConnPool)
+	return d
+}
+
+func (d dokument) replaceDB(db *gorm.DB) dokument {
+	d.dokumentDo.ReplaceDB(db)
+	return d
+}
+
+type dokumentDo struct{ gen.DO }
+
+type IDokumentDo interface {
+	gen.SubQuery
+	Debug() IDokumentDo
+	WithContext(ctx context.Context) IDokumentDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IDokumentDo
+	WriteDB() IDokumentDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IDokumentDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IDokumentDo
+	Not(conds ...gen.Condition) IDokumentDo
+	Or(conds ...gen.Condition) IDokumentDo
+	Select(conds ...field.Expr) IDokumentDo
+	Where(conds ...gen.Condition) IDokumentDo
+	Order(conds ...field.Expr) IDokumentDo
+	Distinct(cols ...field.Expr) IDokumentDo
+	Omit(cols ...field.Expr) IDokumentDo
+	Join(table schema.Tabler, on ...field.Expr) IDokumentDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo
+	Group(cols ...field.Expr) IDokumentDo
+	Having(conds ...gen.Condition) IDokumentDo
+	Limit(limit int) IDokumentDo
+	Offset(offset int) IDokumentDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo
+	Unscoped() IDokumentDo
+	Create(values ...*model.Dokument) error
+	CreateInBatches(values []*model.Dokument, batchSize int) error
+	Save(values ...*model.Dokument) error
+	First() (*model.Dokument, error)
+	Take() (*model.Dokument, error)
+	Last() (*model.Dokument, error)
+	Find() ([]*model.Dokument, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error)
+	FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Dokument) (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) IDokumentDo
+	Assign(attrs ...field.AssignExpr) IDokumentDo
+	Joins(fields ...field.RelationField) IDokumentDo
+	Preload(fields ...field.RelationField) IDokumentDo
+	FirstOrInit() (*model.Dokument, error)
+	FirstOrCreate() (*model.Dokument, error)
+	FindByPage(offset int, limit int) (result []*model.Dokument, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IDokumentDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (d dokumentDo) Debug() IDokumentDo {
+	return d.withDO(d.DO.Debug())
+}
+
+func (d dokumentDo) WithContext(ctx context.Context) IDokumentDo {
+	return d.withDO(d.DO.WithContext(ctx))
+}
+
+func (d dokumentDo) ReadDB() IDokumentDo {
+	return d.Clauses(dbresolver.Read)
+}
+
+func (d dokumentDo) WriteDB() IDokumentDo {
+	return d.Clauses(dbresolver.Write)
+}
+
+func (d dokumentDo) Session(config *gorm.Session) IDokumentDo {
+	return d.withDO(d.DO.Session(config))
+}
+
+func (d dokumentDo) Clauses(conds ...clause.Expression) IDokumentDo {
+	return d.withDO(d.DO.Clauses(conds...))
+}
+
+func (d dokumentDo) Returning(value interface{}, columns ...string) IDokumentDo {
+	return d.withDO(d.DO.Returning(value, columns...))
+}
+
+func (d dokumentDo) Not(conds ...gen.Condition) IDokumentDo {
+	return d.withDO(d.DO.Not(conds...))
+}
+
+func (d dokumentDo) Or(conds ...gen.Condition) IDokumentDo {
+	return d.withDO(d.DO.Or(conds...))
+}
+
+func (d dokumentDo) Select(conds ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.Select(conds...))
+}
+
+func (d dokumentDo) Where(conds ...gen.Condition) IDokumentDo {
+	return d.withDO(d.DO.Where(conds...))
+}
+
+func (d dokumentDo) Order(conds ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.Order(conds...))
+}
+
+func (d dokumentDo) Distinct(cols ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.Distinct(cols...))
+}
+
+func (d dokumentDo) Omit(cols ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.Omit(cols...))
+}
+
+func (d dokumentDo) Join(table schema.Tabler, on ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.Join(table, on...))
+}
+
+func (d dokumentDo) LeftJoin(table schema.Tabler, on ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.LeftJoin(table, on...))
+}
+
+func (d dokumentDo) RightJoin(table schema.Tabler, on ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.RightJoin(table, on...))
+}
+
+func (d dokumentDo) Group(cols ...field.Expr) IDokumentDo {
+	return d.withDO(d.DO.Group(cols...))
+}
+
+func (d dokumentDo) Having(conds ...gen.Condition) IDokumentDo {
+	return d.withDO(d.DO.Having(conds...))
+}
+
+func (d dokumentDo) Limit(limit int) IDokumentDo {
+	return d.withDO(d.DO.Limit(limit))
+}
+
+func (d dokumentDo) Offset(offset int) IDokumentDo {
+	return d.withDO(d.DO.Offset(offset))
+}
+
+func (d dokumentDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IDokumentDo {
+	return d.withDO(d.DO.Scopes(funcs...))
+}
+
+func (d dokumentDo) Unscoped() IDokumentDo {
+	return d.withDO(d.DO.Unscoped())
+}
+
+func (d dokumentDo) Create(values ...*model.Dokument) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return d.DO.Create(values)
+}
+
+func (d dokumentDo) CreateInBatches(values []*model.Dokument, 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 dokumentDo) Save(values ...*model.Dokument) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return d.DO.Save(values)
+}
+
+func (d dokumentDo) First() (*model.Dokument, error) {
+	if result, err := d.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Dokument), nil
+	}
+}
+
+func (d dokumentDo) Take() (*model.Dokument, error) {
+	if result, err := d.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Dokument), nil
+	}
+}
+
+func (d dokumentDo) Last() (*model.Dokument, error) {
+	if result, err := d.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Dokument), nil
+	}
+}
+
+func (d dokumentDo) Find() ([]*model.Dokument, error) {
+	result, err := d.DO.Find()
+	return result.([]*model.Dokument), err
+}
+
+func (d dokumentDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Dokument, err error) {
+	buf := make([]*model.Dokument, 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 dokumentDo) FindInBatches(result *[]*model.Dokument, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return d.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (d dokumentDo) Attrs(attrs ...field.AssignExpr) IDokumentDo {
+	return d.withDO(d.DO.Attrs(attrs...))
+}
+
+func (d dokumentDo) Assign(attrs ...field.AssignExpr) IDokumentDo {
+	return d.withDO(d.DO.Assign(attrs...))
+}
+
+func (d dokumentDo) Joins(fields ...field.RelationField) IDokumentDo {
+	for _, _f := range fields {
+		d = *d.withDO(d.DO.Joins(_f))
+	}
+	return &d
+}
+
+func (d dokumentDo) Preload(fields ...field.RelationField) IDokumentDo {
+	for _, _f := range fields {
+		d = *d.withDO(d.DO.Preload(_f))
+	}
+	return &d
+}
+
+func (d dokumentDo) FirstOrInit() (*model.Dokument, error) {
+	if result, err := d.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Dokument), nil
+	}
+}
+
+func (d dokumentDo) FirstOrCreate() (*model.Dokument, error) {
+	if result, err := d.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Dokument), nil
+	}
+}
+
+func (d dokumentDo) FindByPage(offset int, limit int) (result []*model.Dokument, 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 dokumentDo) 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 dokumentDo) Scan(result interface{}) (err error) {
+	return d.DO.Scan(result)
+}
+
+func (d dokumentDo) Delete(models ...*model.Dokument) (result gen.ResultInfo, err error) {
+	return d.DO.Delete(models)
+}
+
+func (d *dokumentDo) withDO(do gen.Dao) *dokumentDo {
+	d.DO = *do.(*gen.DO)
+	return d
+}

query/firma_ansprechpartner.gen.go

@@ -0,0 +1,407 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newFirmaAnsprechpartner(db *gorm.DB, opts ...gen.DOOption) firmaAnsprechpartner {
+	_firmaAnsprechpartner := firmaAnsprechpartner{}
+
+	_firmaAnsprechpartner.firmaAnsprechpartnerDo.UseDB(db, opts...)
+	_firmaAnsprechpartner.firmaAnsprechpartnerDo.UseModel(&model.FirmaAnsprechpartner{})
+
+	tableName := _firmaAnsprechpartner.firmaAnsprechpartnerDo.TableName()
+	_firmaAnsprechpartner.ALL = field.NewAsterisk(tableName)
+	_firmaAnsprechpartner.ID = field.NewUint(tableName, "id")
+	_firmaAnsprechpartner.CreatedAt = field.NewTime(tableName, "created_at")
+	_firmaAnsprechpartner.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_firmaAnsprechpartner.DeletedAt = field.NewField(tableName, "deleted_at")
+	_firmaAnsprechpartner.AnsprechpartnerId = field.NewUint(tableName, "ansprechpartner_id")
+	_firmaAnsprechpartner.FirmaId = field.NewUint(tableName, "firma_id")
+	_firmaAnsprechpartner.Role = field.NewString(tableName, "role")
+
+	_firmaAnsprechpartner.fillFieldMap()
+
+	return _firmaAnsprechpartner
+}
+
+type firmaAnsprechpartner struct {
+	firmaAnsprechpartnerDo
+
+	ALL               field.Asterisk
+	ID                field.Uint
+	CreatedAt         field.Time
+	UpdatedAt         field.Time
+	DeletedAt         field.Field
+	AnsprechpartnerId field.Uint
+	FirmaId           field.Uint
+	Role              field.String
+
+	fieldMap map[string]field.Expr
+}
+
+func (f firmaAnsprechpartner) Table(newTableName string) *firmaAnsprechpartner {
+	f.firmaAnsprechpartnerDo.UseTable(newTableName)
+	return f.updateTableName(newTableName)
+}
+
+func (f firmaAnsprechpartner) As(alias string) *firmaAnsprechpartner {
+	f.firmaAnsprechpartnerDo.DO = *(f.firmaAnsprechpartnerDo.As(alias).(*gen.DO))
+	return f.updateTableName(alias)
+}
+
+func (f *firmaAnsprechpartner) updateTableName(table string) *firmaAnsprechpartner {
+	f.ALL = field.NewAsterisk(table)
+	f.ID = field.NewUint(table, "id")
+	f.CreatedAt = field.NewTime(table, "created_at")
+	f.UpdatedAt = field.NewTime(table, "updated_at")
+	f.DeletedAt = field.NewField(table, "deleted_at")
+	f.AnsprechpartnerId = field.NewUint(table, "ansprechpartner_id")
+	f.FirmaId = field.NewUint(table, "firma_id")
+	f.Role = field.NewString(table, "role")
+
+	f.fillFieldMap()
+
+	return f
+}
+
+func (f *firmaAnsprechpartner) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := f.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (f *firmaAnsprechpartner) fillFieldMap() {
+	f.fieldMap = make(map[string]field.Expr, 7)
+	f.fieldMap["id"] = f.ID
+	f.fieldMap["created_at"] = f.CreatedAt
+	f.fieldMap["updated_at"] = f.UpdatedAt
+	f.fieldMap["deleted_at"] = f.DeletedAt
+	f.fieldMap["ansprechpartner_id"] = f.AnsprechpartnerId
+	f.fieldMap["firma_id"] = f.FirmaId
+	f.fieldMap["role"] = f.Role
+}
+
+func (f firmaAnsprechpartner) clone(db *gorm.DB) firmaAnsprechpartner {
+	f.firmaAnsprechpartnerDo.ReplaceConnPool(db.Statement.ConnPool)
+	return f
+}
+
+func (f firmaAnsprechpartner) replaceDB(db *gorm.DB) firmaAnsprechpartner {
+	f.firmaAnsprechpartnerDo.ReplaceDB(db)
+	return f
+}
+
+type firmaAnsprechpartnerDo struct{ gen.DO }
+
+type IFirmaAnsprechpartnerDo interface {
+	gen.SubQuery
+	Debug() IFirmaAnsprechpartnerDo
+	WithContext(ctx context.Context) IFirmaAnsprechpartnerDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IFirmaAnsprechpartnerDo
+	WriteDB() IFirmaAnsprechpartnerDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IFirmaAnsprechpartnerDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo
+	Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo
+	Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo
+	Select(conds ...field.Expr) IFirmaAnsprechpartnerDo
+	Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo
+	Order(conds ...field.Expr) IFirmaAnsprechpartnerDo
+	Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo
+	Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo
+	Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo
+	Group(cols ...field.Expr) IFirmaAnsprechpartnerDo
+	Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo
+	Limit(limit int) IFirmaAnsprechpartnerDo
+	Offset(offset int) IFirmaAnsprechpartnerDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo
+	Unscoped() IFirmaAnsprechpartnerDo
+	Create(values ...*model.FirmaAnsprechpartner) error
+	CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error
+	Save(values ...*model.FirmaAnsprechpartner) error
+	First() (*model.FirmaAnsprechpartner, error)
+	Take() (*model.FirmaAnsprechpartner, error)
+	Last() (*model.FirmaAnsprechpartner, error)
+	Find() ([]*model.FirmaAnsprechpartner, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error)
+	FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.FirmaAnsprechpartner) (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) IFirmaAnsprechpartnerDo
+	Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo
+	Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo
+	Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo
+	FirstOrInit() (*model.FirmaAnsprechpartner, error)
+	FirstOrCreate() (*model.FirmaAnsprechpartner, error)
+	FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (f firmaAnsprechpartnerDo) Debug() IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Debug())
+}
+
+func (f firmaAnsprechpartnerDo) WithContext(ctx context.Context) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.WithContext(ctx))
+}
+
+func (f firmaAnsprechpartnerDo) ReadDB() IFirmaAnsprechpartnerDo {
+	return f.Clauses(dbresolver.Read)
+}
+
+func (f firmaAnsprechpartnerDo) WriteDB() IFirmaAnsprechpartnerDo {
+	return f.Clauses(dbresolver.Write)
+}
+
+func (f firmaAnsprechpartnerDo) Session(config *gorm.Session) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Session(config))
+}
+
+func (f firmaAnsprechpartnerDo) Clauses(conds ...clause.Expression) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Clauses(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Returning(value interface{}, columns ...string) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Returning(value, columns...))
+}
+
+func (f firmaAnsprechpartnerDo) Not(conds ...gen.Condition) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Not(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Or(conds ...gen.Condition) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Or(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Select(conds ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Select(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Where(conds ...gen.Condition) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Where(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Order(conds ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Order(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Distinct(cols ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Distinct(cols...))
+}
+
+func (f firmaAnsprechpartnerDo) Omit(cols ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Omit(cols...))
+}
+
+func (f firmaAnsprechpartnerDo) Join(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Join(table, on...))
+}
+
+func (f firmaAnsprechpartnerDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.LeftJoin(table, on...))
+}
+
+func (f firmaAnsprechpartnerDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.RightJoin(table, on...))
+}
+
+func (f firmaAnsprechpartnerDo) Group(cols ...field.Expr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Group(cols...))
+}
+
+func (f firmaAnsprechpartnerDo) Having(conds ...gen.Condition) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Having(conds...))
+}
+
+func (f firmaAnsprechpartnerDo) Limit(limit int) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Limit(limit))
+}
+
+func (f firmaAnsprechpartnerDo) Offset(offset int) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Offset(offset))
+}
+
+func (f firmaAnsprechpartnerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Scopes(funcs...))
+}
+
+func (f firmaAnsprechpartnerDo) Unscoped() IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Unscoped())
+}
+
+func (f firmaAnsprechpartnerDo) Create(values ...*model.FirmaAnsprechpartner) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return f.DO.Create(values)
+}
+
+func (f firmaAnsprechpartnerDo) CreateInBatches(values []*model.FirmaAnsprechpartner, batchSize int) error {
+	return f.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 (f firmaAnsprechpartnerDo) Save(values ...*model.FirmaAnsprechpartner) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return f.DO.Save(values)
+}
+
+func (f firmaAnsprechpartnerDo) First() (*model.FirmaAnsprechpartner, error) {
+	if result, err := f.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.FirmaAnsprechpartner), nil
+	}
+}
+
+func (f firmaAnsprechpartnerDo) Take() (*model.FirmaAnsprechpartner, error) {
+	if result, err := f.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.FirmaAnsprechpartner), nil
+	}
+}
+
+func (f firmaAnsprechpartnerDo) Last() (*model.FirmaAnsprechpartner, error) {
+	if result, err := f.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.FirmaAnsprechpartner), nil
+	}
+}
+
+func (f firmaAnsprechpartnerDo) Find() ([]*model.FirmaAnsprechpartner, error) {
+	result, err := f.DO.Find()
+	return result.([]*model.FirmaAnsprechpartner), err
+}
+
+func (f firmaAnsprechpartnerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.FirmaAnsprechpartner, err error) {
+	buf := make([]*model.FirmaAnsprechpartner, 0, batchSize)
+	err = f.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 (f firmaAnsprechpartnerDo) FindInBatches(result *[]*model.FirmaAnsprechpartner, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return f.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (f firmaAnsprechpartnerDo) Attrs(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Attrs(attrs...))
+}
+
+func (f firmaAnsprechpartnerDo) Assign(attrs ...field.AssignExpr) IFirmaAnsprechpartnerDo {
+	return f.withDO(f.DO.Assign(attrs...))
+}
+
+func (f firmaAnsprechpartnerDo) Joins(fields ...field.RelationField) IFirmaAnsprechpartnerDo {
+	for _, _f := range fields {
+		f = *f.withDO(f.DO.Joins(_f))
+	}
+	return &f
+}
+
+func (f firmaAnsprechpartnerDo) Preload(fields ...field.RelationField) IFirmaAnsprechpartnerDo {
+	for _, _f := range fields {
+		f = *f.withDO(f.DO.Preload(_f))
+	}
+	return &f
+}
+
+func (f firmaAnsprechpartnerDo) FirstOrInit() (*model.FirmaAnsprechpartner, error) {
+	if result, err := f.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.FirmaAnsprechpartner), nil
+	}
+}
+
+func (f firmaAnsprechpartnerDo) FirstOrCreate() (*model.FirmaAnsprechpartner, error) {
+	if result, err := f.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.FirmaAnsprechpartner), nil
+	}
+}
+
+func (f firmaAnsprechpartnerDo) FindByPage(offset int, limit int) (result []*model.FirmaAnsprechpartner, count int64, err error) {
+	result, err = f.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 = f.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (f firmaAnsprechpartnerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = f.Count()
+	if err != nil {
+		return
+	}
+
+	err = f.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (f firmaAnsprechpartnerDo) Scan(result interface{}) (err error) {
+	return f.DO.Scan(result)
+}
+
+func (f firmaAnsprechpartnerDo) Delete(models ...*model.FirmaAnsprechpartner) (result gen.ResultInfo, err error) {
+	return f.DO.Delete(models)
+}
+
+func (f *firmaAnsprechpartnerDo) withDO(do gen.Dao) *firmaAnsprechpartnerDo {
+	f.DO = *do.(*gen.DO)
+	return f
+}

query/firmas.gen.go

@@ -0,0 +1,630 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newFirma(db *gorm.DB, opts ...gen.DOOption) firma {
+	_firma := firma{}
+
+	_firma.firmaDo.UseDB(db, opts...)
+	_firma.firmaDo.UseModel(&model.Firma{})
+
+	tableName := _firma.firmaDo.TableName()
+	_firma.ALL = field.NewAsterisk(tableName)
+	_firma.ID = field.NewUint(tableName, "id")
+	_firma.CreatedAt = field.NewTime(tableName, "created_at")
+	_firma.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_firma.DeletedAt = field.NewField(tableName, "deleted_at")
+	_firma.FirmaTyp = field.NewInt(tableName, "firma_typ")
+	_firma.Name = field.NewString(tableName, "name")
+	_firma.InternerName = field.NewString(tableName, "interner_name")
+	_firma.Slug = field.NewString(tableName, "slug")
+	_firma.Branche = field.NewString(tableName, "branche")
+	_firma.ParentCompany = field.NewUint(tableName, "parent_company")
+	_firma.Tochergesellschaften = firmaHasManyTochergesellschaften{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Tochergesellschaften", "model.Firma"),
+		Tochergesellschaften: struct {
+			field.RelationField
+		}{
+			RelationField: field.NewRelation("Tochergesellschaften.Tochergesellschaften", "model.Firma"),
+		},
+		Ansprechpartner: struct {
+			field.RelationField
+			Firmen struct {
+				field.RelationField
+			}
+		}{
+			RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner", "model.Ansprechpartner"),
+			Firmen: struct {
+				field.RelationField
+			}{
+				RelationField: field.NewRelation("Tochergesellschaften.Ansprechpartner.Firmen", "model.Firma"),
+			},
+		},
+	}
+
+	_firma.Ansprechpartner = firmaManyToManyAnsprechpartner{
+		db: db.Session(&gorm.Session{}),
+
+		RelationField: field.NewRelation("Ansprechpartner", "model.Ansprechpartner"),
+	}
+
+	_firma.fillFieldMap()
+
+	return _firma
+}
+
+type firma struct {
+	firmaDo
+
+	ALL                  field.Asterisk
+	ID                   field.Uint
+	CreatedAt            field.Time
+	UpdatedAt            field.Time
+	DeletedAt            field.Field
+	FirmaTyp             field.Int
+	Name                 field.String
+	InternerName         field.String
+	Slug                 field.String
+	Branche              field.String
+	ParentCompany        field.Uint
+	Tochergesellschaften firmaHasManyTochergesellschaften
+
+	Ansprechpartner firmaManyToManyAnsprechpartner
+
+	fieldMap map[string]field.Expr
+}
+
+func (f firma) Table(newTableName string) *firma {
+	f.firmaDo.UseTable(newTableName)
+	return f.updateTableName(newTableName)
+}
+
+func (f firma) As(alias string) *firma {
+	f.firmaDo.DO = *(f.firmaDo.As(alias).(*gen.DO))
+	return f.updateTableName(alias)
+}
+
+func (f *firma) updateTableName(table string) *firma {
+	f.ALL = field.NewAsterisk(table)
+	f.ID = field.NewUint(table, "id")
+	f.CreatedAt = field.NewTime(table, "created_at")
+	f.UpdatedAt = field.NewTime(table, "updated_at")
+	f.DeletedAt = field.NewField(table, "deleted_at")
+	f.FirmaTyp = field.NewInt(table, "firma_typ")
+	f.Name = field.NewString(table, "name")
+	f.InternerName = field.NewString(table, "interner_name")
+	f.Slug = field.NewString(table, "slug")
+	f.Branche = field.NewString(table, "branche")
+	f.ParentCompany = field.NewUint(table, "parent_company")
+
+	f.fillFieldMap()
+
+	return f
+}
+
+func (f *firma) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := f.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (f *firma) fillFieldMap() {
+	f.fieldMap = make(map[string]field.Expr, 12)
+	f.fieldMap["id"] = f.ID
+	f.fieldMap["created_at"] = f.CreatedAt
+	f.fieldMap["updated_at"] = f.UpdatedAt
+	f.fieldMap["deleted_at"] = f.DeletedAt
+	f.fieldMap["firma_typ"] = f.FirmaTyp
+	f.fieldMap["name"] = f.Name
+	f.fieldMap["interner_name"] = f.InternerName
+	f.fieldMap["slug"] = f.Slug
+	f.fieldMap["branche"] = f.Branche
+	f.fieldMap["parent_company"] = f.ParentCompany
+
+}
+
+func (f firma) clone(db *gorm.DB) firma {
+	f.firmaDo.ReplaceConnPool(db.Statement.ConnPool)
+	f.Tochergesellschaften.db = db.Session(&gorm.Session{Initialized: true})
+	f.Tochergesellschaften.db.Statement.ConnPool = db.Statement.ConnPool
+	f.Ansprechpartner.db = db.Session(&gorm.Session{Initialized: true})
+	f.Ansprechpartner.db.Statement.ConnPool = db.Statement.ConnPool
+	return f
+}
+
+func (f firma) replaceDB(db *gorm.DB) firma {
+	f.firmaDo.ReplaceDB(db)
+	f.Tochergesellschaften.db = db.Session(&gorm.Session{})
+	f.Ansprechpartner.db = db.Session(&gorm.Session{})
+	return f
+}
+
+type firmaHasManyTochergesellschaften struct {
+	db *gorm.DB
+
+	field.RelationField
+
+	Tochergesellschaften struct {
+		field.RelationField
+	}
+	Ansprechpartner struct {
+		field.RelationField
+		Firmen struct {
+			field.RelationField
+		}
+	}
+}
+
+func (a firmaHasManyTochergesellschaften) Where(conds ...field.Expr) *firmaHasManyTochergesellschaften {
+	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 firmaHasManyTochergesellschaften) WithContext(ctx context.Context) *firmaHasManyTochergesellschaften {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a firmaHasManyTochergesellschaften) Session(session *gorm.Session) *firmaHasManyTochergesellschaften {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a firmaHasManyTochergesellschaften) Model(m *model.Firma) *firmaHasManyTochergesellschaftenTx {
+	return &firmaHasManyTochergesellschaftenTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a firmaHasManyTochergesellschaften) Unscoped() *firmaHasManyTochergesellschaften {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type firmaHasManyTochergesellschaftenTx struct{ tx *gorm.Association }
+
+func (a firmaHasManyTochergesellschaftenTx) Find() (result []*model.Firma, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a firmaHasManyTochergesellschaftenTx) Append(values ...*model.Firma) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a firmaHasManyTochergesellschaftenTx) Replace(values ...*model.Firma) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a firmaHasManyTochergesellschaftenTx) Delete(values ...*model.Firma) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a firmaHasManyTochergesellschaftenTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a firmaHasManyTochergesellschaftenTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a firmaHasManyTochergesellschaftenTx) Unscoped() *firmaHasManyTochergesellschaftenTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type firmaManyToManyAnsprechpartner struct {
+	db *gorm.DB
+
+	field.RelationField
+}
+
+func (a firmaManyToManyAnsprechpartner) Where(conds ...field.Expr) *firmaManyToManyAnsprechpartner {
+	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 firmaManyToManyAnsprechpartner) WithContext(ctx context.Context) *firmaManyToManyAnsprechpartner {
+	a.db = a.db.WithContext(ctx)
+	return &a
+}
+
+func (a firmaManyToManyAnsprechpartner) Session(session *gorm.Session) *firmaManyToManyAnsprechpartner {
+	a.db = a.db.Session(session)
+	return &a
+}
+
+func (a firmaManyToManyAnsprechpartner) Model(m *model.Firma) *firmaManyToManyAnsprechpartnerTx {
+	return &firmaManyToManyAnsprechpartnerTx{a.db.Model(m).Association(a.Name())}
+}
+
+func (a firmaManyToManyAnsprechpartner) Unscoped() *firmaManyToManyAnsprechpartner {
+	a.db = a.db.Unscoped()
+	return &a
+}
+
+type firmaManyToManyAnsprechpartnerTx struct{ tx *gorm.Association }
+
+func (a firmaManyToManyAnsprechpartnerTx) Find() (result []*model.Ansprechpartner, err error) {
+	return result, a.tx.Find(&result)
+}
+
+func (a firmaManyToManyAnsprechpartnerTx) Append(values ...*model.Ansprechpartner) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Append(targetValues...)
+}
+
+func (a firmaManyToManyAnsprechpartnerTx) Replace(values ...*model.Ansprechpartner) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Replace(targetValues...)
+}
+
+func (a firmaManyToManyAnsprechpartnerTx) Delete(values ...*model.Ansprechpartner) (err error) {
+	targetValues := make([]interface{}, len(values))
+	for i, v := range values {
+		targetValues[i] = v
+	}
+	return a.tx.Delete(targetValues...)
+}
+
+func (a firmaManyToManyAnsprechpartnerTx) Clear() error {
+	return a.tx.Clear()
+}
+
+func (a firmaManyToManyAnsprechpartnerTx) Count() int64 {
+	return a.tx.Count()
+}
+
+func (a firmaManyToManyAnsprechpartnerTx) Unscoped() *firmaManyToManyAnsprechpartnerTx {
+	a.tx = a.tx.Unscoped()
+	return &a
+}
+
+type firmaDo struct{ gen.DO }
+
+type IFirmaDo interface {
+	gen.SubQuery
+	Debug() IFirmaDo
+	WithContext(ctx context.Context) IFirmaDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IFirmaDo
+	WriteDB() IFirmaDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IFirmaDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IFirmaDo
+	Not(conds ...gen.Condition) IFirmaDo
+	Or(conds ...gen.Condition) IFirmaDo
+	Select(conds ...field.Expr) IFirmaDo
+	Where(conds ...gen.Condition) IFirmaDo
+	Order(conds ...field.Expr) IFirmaDo
+	Distinct(cols ...field.Expr) IFirmaDo
+	Omit(cols ...field.Expr) IFirmaDo
+	Join(table schema.Tabler, on ...field.Expr) IFirmaDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo
+	Group(cols ...field.Expr) IFirmaDo
+	Having(conds ...gen.Condition) IFirmaDo
+	Limit(limit int) IFirmaDo
+	Offset(offset int) IFirmaDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo
+	Unscoped() IFirmaDo
+	Create(values ...*model.Firma) error
+	CreateInBatches(values []*model.Firma, batchSize int) error
+	Save(values ...*model.Firma) error
+	First() (*model.Firma, error)
+	Take() (*model.Firma, error)
+	Last() (*model.Firma, error)
+	Find() ([]*model.Firma, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error)
+	FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Firma) (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) IFirmaDo
+	Assign(attrs ...field.AssignExpr) IFirmaDo
+	Joins(fields ...field.RelationField) IFirmaDo
+	Preload(fields ...field.RelationField) IFirmaDo
+	FirstOrInit() (*model.Firma, error)
+	FirstOrCreate() (*model.Firma, error)
+	FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IFirmaDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (f firmaDo) Debug() IFirmaDo {
+	return f.withDO(f.DO.Debug())
+}
+
+func (f firmaDo) WithContext(ctx context.Context) IFirmaDo {
+	return f.withDO(f.DO.WithContext(ctx))
+}
+
+func (f firmaDo) ReadDB() IFirmaDo {
+	return f.Clauses(dbresolver.Read)
+}
+
+func (f firmaDo) WriteDB() IFirmaDo {
+	return f.Clauses(dbresolver.Write)
+}
+
+func (f firmaDo) Session(config *gorm.Session) IFirmaDo {
+	return f.withDO(f.DO.Session(config))
+}
+
+func (f firmaDo) Clauses(conds ...clause.Expression) IFirmaDo {
+	return f.withDO(f.DO.Clauses(conds...))
+}
+
+func (f firmaDo) Returning(value interface{}, columns ...string) IFirmaDo {
+	return f.withDO(f.DO.Returning(value, columns...))
+}
+
+func (f firmaDo) Not(conds ...gen.Condition) IFirmaDo {
+	return f.withDO(f.DO.Not(conds...))
+}
+
+func (f firmaDo) Or(conds ...gen.Condition) IFirmaDo {
+	return f.withDO(f.DO.Or(conds...))
+}
+
+func (f firmaDo) Select(conds ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.Select(conds...))
+}
+
+func (f firmaDo) Where(conds ...gen.Condition) IFirmaDo {
+	return f.withDO(f.DO.Where(conds...))
+}
+
+func (f firmaDo) Order(conds ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.Order(conds...))
+}
+
+func (f firmaDo) Distinct(cols ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.Distinct(cols...))
+}
+
+func (f firmaDo) Omit(cols ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.Omit(cols...))
+}
+
+func (f firmaDo) Join(table schema.Tabler, on ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.Join(table, on...))
+}
+
+func (f firmaDo) LeftJoin(table schema.Tabler, on ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.LeftJoin(table, on...))
+}
+
+func (f firmaDo) RightJoin(table schema.Tabler, on ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.RightJoin(table, on...))
+}
+
+func (f firmaDo) Group(cols ...field.Expr) IFirmaDo {
+	return f.withDO(f.DO.Group(cols...))
+}
+
+func (f firmaDo) Having(conds ...gen.Condition) IFirmaDo {
+	return f.withDO(f.DO.Having(conds...))
+}
+
+func (f firmaDo) Limit(limit int) IFirmaDo {
+	return f.withDO(f.DO.Limit(limit))
+}
+
+func (f firmaDo) Offset(offset int) IFirmaDo {
+	return f.withDO(f.DO.Offset(offset))
+}
+
+func (f firmaDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IFirmaDo {
+	return f.withDO(f.DO.Scopes(funcs...))
+}
+
+func (f firmaDo) Unscoped() IFirmaDo {
+	return f.withDO(f.DO.Unscoped())
+}
+
+func (f firmaDo) Create(values ...*model.Firma) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return f.DO.Create(values)
+}
+
+func (f firmaDo) CreateInBatches(values []*model.Firma, batchSize int) error {
+	return f.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 (f firmaDo) Save(values ...*model.Firma) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return f.DO.Save(values)
+}
+
+func (f firmaDo) First() (*model.Firma, error) {
+	if result, err := f.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Firma), nil
+	}
+}
+
+func (f firmaDo) Take() (*model.Firma, error) {
+	if result, err := f.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Firma), nil
+	}
+}
+
+func (f firmaDo) Last() (*model.Firma, error) {
+	if result, err := f.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Firma), nil
+	}
+}
+
+func (f firmaDo) Find() ([]*model.Firma, error) {
+	result, err := f.DO.Find()
+	return result.([]*model.Firma), err
+}
+
+func (f firmaDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Firma, err error) {
+	buf := make([]*model.Firma, 0, batchSize)
+	err = f.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 (f firmaDo) FindInBatches(result *[]*model.Firma, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return f.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (f firmaDo) Attrs(attrs ...field.AssignExpr) IFirmaDo {
+	return f.withDO(f.DO.Attrs(attrs...))
+}
+
+func (f firmaDo) Assign(attrs ...field.AssignExpr) IFirmaDo {
+	return f.withDO(f.DO.Assign(attrs...))
+}
+
+func (f firmaDo) Joins(fields ...field.RelationField) IFirmaDo {
+	for _, _f := range fields {
+		f = *f.withDO(f.DO.Joins(_f))
+	}
+	return &f
+}
+
+func (f firmaDo) Preload(fields ...field.RelationField) IFirmaDo {
+	for _, _f := range fields {
+		f = *f.withDO(f.DO.Preload(_f))
+	}
+	return &f
+}
+
+func (f firmaDo) FirstOrInit() (*model.Firma, error) {
+	if result, err := f.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Firma), nil
+	}
+}
+
+func (f firmaDo) FirstOrCreate() (*model.Firma, error) {
+	if result, err := f.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Firma), nil
+	}
+}
+
+func (f firmaDo) FindByPage(offset int, limit int) (result []*model.Firma, count int64, err error) {
+	result, err = f.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 = f.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (f firmaDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = f.Count()
+	if err != nil {
+		return
+	}
+
+	err = f.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (f firmaDo) Scan(result interface{}) (err error) {
+	return f.DO.Scan(result)
+}
+
+func (f firmaDo) Delete(models ...*model.Firma) (result gen.ResultInfo, err error) {
+	return f.DO.Delete(models)
+}
+
+func (f *firmaDo) withDO(do gen.Dao) *firmaDo {
+	f.DO = *do.(*gen.DO)
+	return f
+}

query/gen.go

@@ -0,0 +1,231 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+
+	"gorm.io/gen"
+
+	"gorm.io/plugin/dbresolver"
+)
+
+var (
+	Q                    = new(Query)
+	Ansprechpartner      *ansprechpartner
+	Dokument             *dokument
+	Firma                *firma
+	FirmaAnsprechpartner *firmaAnsprechpartner
+	Kalender             *kalender
+	Kalendereintrag      *kalendereintrag
+	Kostenstelle         *kostenstelle
+	Lager                *lager
+	Lagerplatz           *lagerplatz
+	Material             *material
+	Nachricht            *nachricht
+	Projekt              *projekt
+	Rechnung             *rechnung
+	Rechnungsposition    *rechnungsposition
+	Scanobject           *scanobject
+	User                 *user
+	Zahlung              *zahlung
+)
+
+func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
+	*Q = *Use(db, opts...)
+	Ansprechpartner = &Q.Ansprechpartner
+	Dokument = &Q.Dokument
+	Firma = &Q.Firma
+	FirmaAnsprechpartner = &Q.FirmaAnsprechpartner
+	Kalender = &Q.Kalender
+	Kalendereintrag = &Q.Kalendereintrag
+	Kostenstelle = &Q.Kostenstelle
+	Lager = &Q.Lager
+	Lagerplatz = &Q.Lagerplatz
+	Material = &Q.Material
+	Nachricht = &Q.Nachricht
+	Projekt = &Q.Projekt
+	Rechnung = &Q.Rechnung
+	Rechnungsposition = &Q.Rechnungsposition
+	Scanobject = &Q.Scanobject
+	User = &Q.User
+	Zahlung = &Q.Zahlung
+}
+
+func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
+	return &Query{
+		db:                   db,
+		Ansprechpartner:      newAnsprechpartner(db, opts...),
+		Dokument:             newDokument(db, opts...),
+		Firma:                newFirma(db, opts...),
+		FirmaAnsprechpartner: newFirmaAnsprechpartner(db, opts...),
+		Kalender:             newKalender(db, opts...),
+		Kalendereintrag:      newKalendereintrag(db, opts...),
+		Kostenstelle:         newKostenstelle(db, opts...),
+		Lager:                newLager(db, opts...),
+		Lagerplatz:           newLagerplatz(db, opts...),
+		Material:             newMaterial(db, opts...),
+		Nachricht:            newNachricht(db, opts...),
+		Projekt:              newProjekt(db, opts...),
+		Rechnung:             newRechnung(db, opts...),
+		Rechnungsposition:    newRechnungsposition(db, opts...),
+		Scanobject:           newScanobject(db, opts...),
+		User:                 newUser(db, opts...),
+		Zahlung:              newZahlung(db, opts...),
+	}
+}
+
+type Query struct {
+	db *gorm.DB
+
+	Ansprechpartner      ansprechpartner
+	Dokument             dokument
+	Firma                firma
+	FirmaAnsprechpartner firmaAnsprechpartner
+	Kalender             kalender
+	Kalendereintrag      kalendereintrag
+	Kostenstelle         kostenstelle
+	Lager                lager
+	Lagerplatz           lagerplatz
+	Material             material
+	Nachricht            nachricht
+	Projekt              projekt
+	Rechnung             rechnung
+	Rechnungsposition    rechnungsposition
+	Scanobject           scanobject
+	User                 user
+	Zahlung              zahlung
+}
+
+func (q *Query) Available() bool { return q.db != nil }
+
+func (q *Query) clone(db *gorm.DB) *Query {
+	return &Query{
+		db:                   db,
+		Ansprechpartner:      q.Ansprechpartner.clone(db),
+		Dokument:             q.Dokument.clone(db),
+		Firma:                q.Firma.clone(db),
+		FirmaAnsprechpartner: q.FirmaAnsprechpartner.clone(db),
+		Kalender:             q.Kalender.clone(db),
+		Kalendereintrag:      q.Kalendereintrag.clone(db),
+		Kostenstelle:         q.Kostenstelle.clone(db),
+		Lager:                q.Lager.clone(db),
+		Lagerplatz:           q.Lagerplatz.clone(db),
+		Material:             q.Material.clone(db),
+		Nachricht:            q.Nachricht.clone(db),
+		Projekt:              q.Projekt.clone(db),
+		Rechnung:             q.Rechnung.clone(db),
+		Rechnungsposition:    q.Rechnungsposition.clone(db),
+		Scanobject:           q.Scanobject.clone(db),
+		User:                 q.User.clone(db),
+		Zahlung:              q.Zahlung.clone(db),
+	}
+}
+
+func (q *Query) ReadDB() *Query {
+	return q.ReplaceDB(q.db.Clauses(dbresolver.Read))
+}
+
+func (q *Query) WriteDB() *Query {
+	return q.ReplaceDB(q.db.Clauses(dbresolver.Write))
+}
+
+func (q *Query) ReplaceDB(db *gorm.DB) *Query {
+	return &Query{
+		db:                   db,
+		Ansprechpartner:      q.Ansprechpartner.replaceDB(db),
+		Dokument:             q.Dokument.replaceDB(db),
+		Firma:                q.Firma.replaceDB(db),
+		FirmaAnsprechpartner: q.FirmaAnsprechpartner.replaceDB(db),
+		Kalender:             q.Kalender.replaceDB(db),
+		Kalendereintrag:      q.Kalendereintrag.replaceDB(db),
+		Kostenstelle:         q.Kostenstelle.replaceDB(db),
+		Lager:                q.Lager.replaceDB(db),
+		Lagerplatz:           q.Lagerplatz.replaceDB(db),
+		Material:             q.Material.replaceDB(db),
+		Nachricht:            q.Nachricht.replaceDB(db),
+		Projekt:              q.Projekt.replaceDB(db),
+		Rechnung:             q.Rechnung.replaceDB(db),
+		Rechnungsposition:    q.Rechnungsposition.replaceDB(db),
+		Scanobject:           q.Scanobject.replaceDB(db),
+		User:                 q.User.replaceDB(db),
+		Zahlung:              q.Zahlung.replaceDB(db),
+	}
+}
+
+type queryCtx struct {
+	Ansprechpartner      IAnsprechpartnerDo
+	Dokument             IDokumentDo
+	Firma                IFirmaDo
+	FirmaAnsprechpartner IFirmaAnsprechpartnerDo
+	Kalender             IKalenderDo
+	Kalendereintrag      IKalendereintragDo
+	Kostenstelle         IKostenstelleDo
+	Lager                ILagerDo
+	Lagerplatz           ILagerplatzDo
+	Material             IMaterialDo
+	Nachricht            INachrichtDo
+	Projekt              IProjektDo
+	Rechnung             IRechnungDo
+	Rechnungsposition    IRechnungspositionDo
+	Scanobject           IScanobjectDo
+	User                 IUserDo
+	Zahlung              IZahlungDo
+}
+
+func (q *Query) WithContext(ctx context.Context) *queryCtx {
+	return &queryCtx{
+		Ansprechpartner:      q.Ansprechpartner.WithContext(ctx),
+		Dokument:             q.Dokument.WithContext(ctx),
+		Firma:                q.Firma.WithContext(ctx),
+		FirmaAnsprechpartner: q.FirmaAnsprechpartner.WithContext(ctx),
+		Kalender:             q.Kalender.WithContext(ctx),
+		Kalendereintrag:      q.Kalendereintrag.WithContext(ctx),
+		Kostenstelle:         q.Kostenstelle.WithContext(ctx),
+		Lager:                q.Lager.WithContext(ctx),
+		Lagerplatz:           q.Lagerplatz.WithContext(ctx),
+		Material:             q.Material.WithContext(ctx),
+		Nachricht:            q.Nachricht.WithContext(ctx),
+		Projekt:              q.Projekt.WithContext(ctx),
+		Rechnung:             q.Rechnung.WithContext(ctx),
+		Rechnungsposition:    q.Rechnungsposition.WithContext(ctx),
+		Scanobject:           q.Scanobject.WithContext(ctx),
+		User:                 q.User.WithContext(ctx),
+		Zahlung:              q.Zahlung.WithContext(ctx),
+	}
+}
+
+func (q *Query) Transaction(fc func(tx *Query) error, opts ...*sql.TxOptions) error {
+	return q.db.Transaction(func(tx *gorm.DB) error { return fc(q.clone(tx)) }, opts...)
+}
+
+func (q *Query) Begin(opts ...*sql.TxOptions) *QueryTx {
+	tx := q.db.Begin(opts...)
+	return &QueryTx{Query: q.clone(tx), Error: tx.Error}
+}
+
+type QueryTx struct {
+	*Query
+	Error error
+}
+
+func (q *QueryTx) Commit() error {
+	return q.db.Commit().Error
+}
+
+func (q *QueryTx) Rollback() error {
+	return q.db.Rollback().Error
+}
+
+func (q *QueryTx) SavePoint(name string) error {
+	return q.db.SavePoint(name).Error
+}
+
+func (q *QueryTx) RollbackTo(name string) error {
+	return q.db.RollbackTo(name).Error
+}

query/kalendereintrags.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newKalendereintrag(db *gorm.DB, opts ...gen.DOOption) kalendereintrag {
+	_kalendereintrag := kalendereintrag{}
+
+	_kalendereintrag.kalendereintragDo.UseDB(db, opts...)
+	_kalendereintrag.kalendereintragDo.UseModel(&model.Kalendereintrag{})
+
+	tableName := _kalendereintrag.kalendereintragDo.TableName()
+	_kalendereintrag.ALL = field.NewAsterisk(tableName)
+	_kalendereintrag.ID = field.NewUint(tableName, "id")
+	_kalendereintrag.CreatedAt = field.NewTime(tableName, "created_at")
+	_kalendereintrag.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_kalendereintrag.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_kalendereintrag.fillFieldMap()
+
+	return _kalendereintrag
+}
+
+type kalendereintrag struct {
+	kalendereintragDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (k kalendereintrag) Table(newTableName string) *kalendereintrag {
+	k.kalendereintragDo.UseTable(newTableName)
+	return k.updateTableName(newTableName)
+}
+
+func (k kalendereintrag) As(alias string) *kalendereintrag {
+	k.kalendereintragDo.DO = *(k.kalendereintragDo.As(alias).(*gen.DO))
+	return k.updateTableName(alias)
+}
+
+func (k *kalendereintrag) updateTableName(table string) *kalendereintrag {
+	k.ALL = field.NewAsterisk(table)
+	k.ID = field.NewUint(table, "id")
+	k.CreatedAt = field.NewTime(table, "created_at")
+	k.UpdatedAt = field.NewTime(table, "updated_at")
+	k.DeletedAt = field.NewField(table, "deleted_at")
+
+	k.fillFieldMap()
+
+	return k
+}
+
+func (k *kalendereintrag) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := k.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (k *kalendereintrag) fillFieldMap() {
+	k.fieldMap = make(map[string]field.Expr, 4)
+	k.fieldMap["id"] = k.ID
+	k.fieldMap["created_at"] = k.CreatedAt
+	k.fieldMap["updated_at"] = k.UpdatedAt
+	k.fieldMap["deleted_at"] = k.DeletedAt
+}
+
+func (k kalendereintrag) clone(db *gorm.DB) kalendereintrag {
+	k.kalendereintragDo.ReplaceConnPool(db.Statement.ConnPool)
+	return k
+}
+
+func (k kalendereintrag) replaceDB(db *gorm.DB) kalendereintrag {
+	k.kalendereintragDo.ReplaceDB(db)
+	return k
+}
+
+type kalendereintragDo struct{ gen.DO }
+
+type IKalendereintragDo interface {
+	gen.SubQuery
+	Debug() IKalendereintragDo
+	WithContext(ctx context.Context) IKalendereintragDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IKalendereintragDo
+	WriteDB() IKalendereintragDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IKalendereintragDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IKalendereintragDo
+	Not(conds ...gen.Condition) IKalendereintragDo
+	Or(conds ...gen.Condition) IKalendereintragDo
+	Select(conds ...field.Expr) IKalendereintragDo
+	Where(conds ...gen.Condition) IKalendereintragDo
+	Order(conds ...field.Expr) IKalendereintragDo
+	Distinct(cols ...field.Expr) IKalendereintragDo
+	Omit(cols ...field.Expr) IKalendereintragDo
+	Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo
+	Group(cols ...field.Expr) IKalendereintragDo
+	Having(conds ...gen.Condition) IKalendereintragDo
+	Limit(limit int) IKalendereintragDo
+	Offset(offset int) IKalendereintragDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo
+	Unscoped() IKalendereintragDo
+	Create(values ...*model.Kalendereintrag) error
+	CreateInBatches(values []*model.Kalendereintrag, batchSize int) error
+	Save(values ...*model.Kalendereintrag) error
+	First() (*model.Kalendereintrag, error)
+	Take() (*model.Kalendereintrag, error)
+	Last() (*model.Kalendereintrag, error)
+	Find() ([]*model.Kalendereintrag, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error)
+	FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Kalendereintrag) (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) IKalendereintragDo
+	Assign(attrs ...field.AssignExpr) IKalendereintragDo
+	Joins(fields ...field.RelationField) IKalendereintragDo
+	Preload(fields ...field.RelationField) IKalendereintragDo
+	FirstOrInit() (*model.Kalendereintrag, error)
+	FirstOrCreate() (*model.Kalendereintrag, error)
+	FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IKalendereintragDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (k kalendereintragDo) Debug() IKalendereintragDo {
+	return k.withDO(k.DO.Debug())
+}
+
+func (k kalendereintragDo) WithContext(ctx context.Context) IKalendereintragDo {
+	return k.withDO(k.DO.WithContext(ctx))
+}
+
+func (k kalendereintragDo) ReadDB() IKalendereintragDo {
+	return k.Clauses(dbresolver.Read)
+}
+
+func (k kalendereintragDo) WriteDB() IKalendereintragDo {
+	return k.Clauses(dbresolver.Write)
+}
+
+func (k kalendereintragDo) Session(config *gorm.Session) IKalendereintragDo {
+	return k.withDO(k.DO.Session(config))
+}
+
+func (k kalendereintragDo) Clauses(conds ...clause.Expression) IKalendereintragDo {
+	return k.withDO(k.DO.Clauses(conds...))
+}
+
+func (k kalendereintragDo) Returning(value interface{}, columns ...string) IKalendereintragDo {
+	return k.withDO(k.DO.Returning(value, columns...))
+}
+
+func (k kalendereintragDo) Not(conds ...gen.Condition) IKalendereintragDo {
+	return k.withDO(k.DO.Not(conds...))
+}
+
+func (k kalendereintragDo) Or(conds ...gen.Condition) IKalendereintragDo {
+	return k.withDO(k.DO.Or(conds...))
+}
+
+func (k kalendereintragDo) Select(conds ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.Select(conds...))
+}
+
+func (k kalendereintragDo) Where(conds ...gen.Condition) IKalendereintragDo {
+	return k.withDO(k.DO.Where(conds...))
+}
+
+func (k kalendereintragDo) Order(conds ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.Order(conds...))
+}
+
+func (k kalendereintragDo) Distinct(cols ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.Distinct(cols...))
+}
+
+func (k kalendereintragDo) Omit(cols ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.Omit(cols...))
+}
+
+func (k kalendereintragDo) Join(table schema.Tabler, on ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.Join(table, on...))
+}
+
+func (k kalendereintragDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.LeftJoin(table, on...))
+}
+
+func (k kalendereintragDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.RightJoin(table, on...))
+}
+
+func (k kalendereintragDo) Group(cols ...field.Expr) IKalendereintragDo {
+	return k.withDO(k.DO.Group(cols...))
+}
+
+func (k kalendereintragDo) Having(conds ...gen.Condition) IKalendereintragDo {
+	return k.withDO(k.DO.Having(conds...))
+}
+
+func (k kalendereintragDo) Limit(limit int) IKalendereintragDo {
+	return k.withDO(k.DO.Limit(limit))
+}
+
+func (k kalendereintragDo) Offset(offset int) IKalendereintragDo {
+	return k.withDO(k.DO.Offset(offset))
+}
+
+func (k kalendereintragDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalendereintragDo {
+	return k.withDO(k.DO.Scopes(funcs...))
+}
+
+func (k kalendereintragDo) Unscoped() IKalendereintragDo {
+	return k.withDO(k.DO.Unscoped())
+}
+
+func (k kalendereintragDo) Create(values ...*model.Kalendereintrag) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return k.DO.Create(values)
+}
+
+func (k kalendereintragDo) CreateInBatches(values []*model.Kalendereintrag, batchSize int) error {
+	return k.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 (k kalendereintragDo) Save(values ...*model.Kalendereintrag) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return k.DO.Save(values)
+}
+
+func (k kalendereintragDo) First() (*model.Kalendereintrag, error) {
+	if result, err := k.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalendereintrag), nil
+	}
+}
+
+func (k kalendereintragDo) Take() (*model.Kalendereintrag, error) {
+	if result, err := k.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalendereintrag), nil
+	}
+}
+
+func (k kalendereintragDo) Last() (*model.Kalendereintrag, error) {
+	if result, err := k.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalendereintrag), nil
+	}
+}
+
+func (k kalendereintragDo) Find() ([]*model.Kalendereintrag, error) {
+	result, err := k.DO.Find()
+	return result.([]*model.Kalendereintrag), err
+}
+
+func (k kalendereintragDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalendereintrag, err error) {
+	buf := make([]*model.Kalendereintrag, 0, batchSize)
+	err = k.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 (k kalendereintragDo) FindInBatches(result *[]*model.Kalendereintrag, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return k.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (k kalendereintragDo) Attrs(attrs ...field.AssignExpr) IKalendereintragDo {
+	return k.withDO(k.DO.Attrs(attrs...))
+}
+
+func (k kalendereintragDo) Assign(attrs ...field.AssignExpr) IKalendereintragDo {
+	return k.withDO(k.DO.Assign(attrs...))
+}
+
+func (k kalendereintragDo) Joins(fields ...field.RelationField) IKalendereintragDo {
+	for _, _f := range fields {
+		k = *k.withDO(k.DO.Joins(_f))
+	}
+	return &k
+}
+
+func (k kalendereintragDo) Preload(fields ...field.RelationField) IKalendereintragDo {
+	for _, _f := range fields {
+		k = *k.withDO(k.DO.Preload(_f))
+	}
+	return &k
+}
+
+func (k kalendereintragDo) FirstOrInit() (*model.Kalendereintrag, error) {
+	if result, err := k.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalendereintrag), nil
+	}
+}
+
+func (k kalendereintragDo) FirstOrCreate() (*model.Kalendereintrag, error) {
+	if result, err := k.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalendereintrag), nil
+	}
+}
+
+func (k kalendereintragDo) FindByPage(offset int, limit int) (result []*model.Kalendereintrag, count int64, err error) {
+	result, err = k.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 = k.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (k kalendereintragDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = k.Count()
+	if err != nil {
+		return
+	}
+
+	err = k.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (k kalendereintragDo) Scan(result interface{}) (err error) {
+	return k.DO.Scan(result)
+}
+
+func (k kalendereintragDo) Delete(models ...*model.Kalendereintrag) (result gen.ResultInfo, err error) {
+	return k.DO.Delete(models)
+}
+
+func (k *kalendereintragDo) withDO(do gen.Dao) *kalendereintragDo {
+	k.DO = *do.(*gen.DO)
+	return k
+}

query/kalenders.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newKalender(db *gorm.DB, opts ...gen.DOOption) kalender {
+	_kalender := kalender{}
+
+	_kalender.kalenderDo.UseDB(db, opts...)
+	_kalender.kalenderDo.UseModel(&model.Kalender{})
+
+	tableName := _kalender.kalenderDo.TableName()
+	_kalender.ALL = field.NewAsterisk(tableName)
+	_kalender.ID = field.NewUint(tableName, "id")
+	_kalender.CreatedAt = field.NewTime(tableName, "created_at")
+	_kalender.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_kalender.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_kalender.fillFieldMap()
+
+	return _kalender
+}
+
+type kalender struct {
+	kalenderDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (k kalender) Table(newTableName string) *kalender {
+	k.kalenderDo.UseTable(newTableName)
+	return k.updateTableName(newTableName)
+}
+
+func (k kalender) As(alias string) *kalender {
+	k.kalenderDo.DO = *(k.kalenderDo.As(alias).(*gen.DO))
+	return k.updateTableName(alias)
+}
+
+func (k *kalender) updateTableName(table string) *kalender {
+	k.ALL = field.NewAsterisk(table)
+	k.ID = field.NewUint(table, "id")
+	k.CreatedAt = field.NewTime(table, "created_at")
+	k.UpdatedAt = field.NewTime(table, "updated_at")
+	k.DeletedAt = field.NewField(table, "deleted_at")
+
+	k.fillFieldMap()
+
+	return k
+}
+
+func (k *kalender) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := k.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (k *kalender) fillFieldMap() {
+	k.fieldMap = make(map[string]field.Expr, 4)
+	k.fieldMap["id"] = k.ID
+	k.fieldMap["created_at"] = k.CreatedAt
+	k.fieldMap["updated_at"] = k.UpdatedAt
+	k.fieldMap["deleted_at"] = k.DeletedAt
+}
+
+func (k kalender) clone(db *gorm.DB) kalender {
+	k.kalenderDo.ReplaceConnPool(db.Statement.ConnPool)
+	return k
+}
+
+func (k kalender) replaceDB(db *gorm.DB) kalender {
+	k.kalenderDo.ReplaceDB(db)
+	return k
+}
+
+type kalenderDo struct{ gen.DO }
+
+type IKalenderDo interface {
+	gen.SubQuery
+	Debug() IKalenderDo
+	WithContext(ctx context.Context) IKalenderDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IKalenderDo
+	WriteDB() IKalenderDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IKalenderDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IKalenderDo
+	Not(conds ...gen.Condition) IKalenderDo
+	Or(conds ...gen.Condition) IKalenderDo
+	Select(conds ...field.Expr) IKalenderDo
+	Where(conds ...gen.Condition) IKalenderDo
+	Order(conds ...field.Expr) IKalenderDo
+	Distinct(cols ...field.Expr) IKalenderDo
+	Omit(cols ...field.Expr) IKalenderDo
+	Join(table schema.Tabler, on ...field.Expr) IKalenderDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo
+	Group(cols ...field.Expr) IKalenderDo
+	Having(conds ...gen.Condition) IKalenderDo
+	Limit(limit int) IKalenderDo
+	Offset(offset int) IKalenderDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo
+	Unscoped() IKalenderDo
+	Create(values ...*model.Kalender) error
+	CreateInBatches(values []*model.Kalender, batchSize int) error
+	Save(values ...*model.Kalender) error
+	First() (*model.Kalender, error)
+	Take() (*model.Kalender, error)
+	Last() (*model.Kalender, error)
+	Find() ([]*model.Kalender, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error)
+	FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Kalender) (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) IKalenderDo
+	Assign(attrs ...field.AssignExpr) IKalenderDo
+	Joins(fields ...field.RelationField) IKalenderDo
+	Preload(fields ...field.RelationField) IKalenderDo
+	FirstOrInit() (*model.Kalender, error)
+	FirstOrCreate() (*model.Kalender, error)
+	FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IKalenderDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (k kalenderDo) Debug() IKalenderDo {
+	return k.withDO(k.DO.Debug())
+}
+
+func (k kalenderDo) WithContext(ctx context.Context) IKalenderDo {
+	return k.withDO(k.DO.WithContext(ctx))
+}
+
+func (k kalenderDo) ReadDB() IKalenderDo {
+	return k.Clauses(dbresolver.Read)
+}
+
+func (k kalenderDo) WriteDB() IKalenderDo {
+	return k.Clauses(dbresolver.Write)
+}
+
+func (k kalenderDo) Session(config *gorm.Session) IKalenderDo {
+	return k.withDO(k.DO.Session(config))
+}
+
+func (k kalenderDo) Clauses(conds ...clause.Expression) IKalenderDo {
+	return k.withDO(k.DO.Clauses(conds...))
+}
+
+func (k kalenderDo) Returning(value interface{}, columns ...string) IKalenderDo {
+	return k.withDO(k.DO.Returning(value, columns...))
+}
+
+func (k kalenderDo) Not(conds ...gen.Condition) IKalenderDo {
+	return k.withDO(k.DO.Not(conds...))
+}
+
+func (k kalenderDo) Or(conds ...gen.Condition) IKalenderDo {
+	return k.withDO(k.DO.Or(conds...))
+}
+
+func (k kalenderDo) Select(conds ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.Select(conds...))
+}
+
+func (k kalenderDo) Where(conds ...gen.Condition) IKalenderDo {
+	return k.withDO(k.DO.Where(conds...))
+}
+
+func (k kalenderDo) Order(conds ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.Order(conds...))
+}
+
+func (k kalenderDo) Distinct(cols ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.Distinct(cols...))
+}
+
+func (k kalenderDo) Omit(cols ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.Omit(cols...))
+}
+
+func (k kalenderDo) Join(table schema.Tabler, on ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.Join(table, on...))
+}
+
+func (k kalenderDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.LeftJoin(table, on...))
+}
+
+func (k kalenderDo) RightJoin(table schema.Tabler, on ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.RightJoin(table, on...))
+}
+
+func (k kalenderDo) Group(cols ...field.Expr) IKalenderDo {
+	return k.withDO(k.DO.Group(cols...))
+}
+
+func (k kalenderDo) Having(conds ...gen.Condition) IKalenderDo {
+	return k.withDO(k.DO.Having(conds...))
+}
+
+func (k kalenderDo) Limit(limit int) IKalenderDo {
+	return k.withDO(k.DO.Limit(limit))
+}
+
+func (k kalenderDo) Offset(offset int) IKalenderDo {
+	return k.withDO(k.DO.Offset(offset))
+}
+
+func (k kalenderDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKalenderDo {
+	return k.withDO(k.DO.Scopes(funcs...))
+}
+
+func (k kalenderDo) Unscoped() IKalenderDo {
+	return k.withDO(k.DO.Unscoped())
+}
+
+func (k kalenderDo) Create(values ...*model.Kalender) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return k.DO.Create(values)
+}
+
+func (k kalenderDo) CreateInBatches(values []*model.Kalender, batchSize int) error {
+	return k.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 (k kalenderDo) Save(values ...*model.Kalender) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return k.DO.Save(values)
+}
+
+func (k kalenderDo) First() (*model.Kalender, error) {
+	if result, err := k.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalender), nil
+	}
+}
+
+func (k kalenderDo) Take() (*model.Kalender, error) {
+	if result, err := k.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalender), nil
+	}
+}
+
+func (k kalenderDo) Last() (*model.Kalender, error) {
+	if result, err := k.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalender), nil
+	}
+}
+
+func (k kalenderDo) Find() ([]*model.Kalender, error) {
+	result, err := k.DO.Find()
+	return result.([]*model.Kalender), err
+}
+
+func (k kalenderDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kalender, err error) {
+	buf := make([]*model.Kalender, 0, batchSize)
+	err = k.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 (k kalenderDo) FindInBatches(result *[]*model.Kalender, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return k.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (k kalenderDo) Attrs(attrs ...field.AssignExpr) IKalenderDo {
+	return k.withDO(k.DO.Attrs(attrs...))
+}
+
+func (k kalenderDo) Assign(attrs ...field.AssignExpr) IKalenderDo {
+	return k.withDO(k.DO.Assign(attrs...))
+}
+
+func (k kalenderDo) Joins(fields ...field.RelationField) IKalenderDo {
+	for _, _f := range fields {
+		k = *k.withDO(k.DO.Joins(_f))
+	}
+	return &k
+}
+
+func (k kalenderDo) Preload(fields ...field.RelationField) IKalenderDo {
+	for _, _f := range fields {
+		k = *k.withDO(k.DO.Preload(_f))
+	}
+	return &k
+}
+
+func (k kalenderDo) FirstOrInit() (*model.Kalender, error) {
+	if result, err := k.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalender), nil
+	}
+}
+
+func (k kalenderDo) FirstOrCreate() (*model.Kalender, error) {
+	if result, err := k.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kalender), nil
+	}
+}
+
+func (k kalenderDo) FindByPage(offset int, limit int) (result []*model.Kalender, count int64, err error) {
+	result, err = k.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 = k.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (k kalenderDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = k.Count()
+	if err != nil {
+		return
+	}
+
+	err = k.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (k kalenderDo) Scan(result interface{}) (err error) {
+	return k.DO.Scan(result)
+}
+
+func (k kalenderDo) Delete(models ...*model.Kalender) (result gen.ResultInfo, err error) {
+	return k.DO.Delete(models)
+}
+
+func (k *kalenderDo) withDO(do gen.Dao) *kalenderDo {
+	k.DO = *do.(*gen.DO)
+	return k
+}

query/kostenstelles.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newKostenstelle(db *gorm.DB, opts ...gen.DOOption) kostenstelle {
+	_kostenstelle := kostenstelle{}
+
+	_kostenstelle.kostenstelleDo.UseDB(db, opts...)
+	_kostenstelle.kostenstelleDo.UseModel(&model.Kostenstelle{})
+
+	tableName := _kostenstelle.kostenstelleDo.TableName()
+	_kostenstelle.ALL = field.NewAsterisk(tableName)
+	_kostenstelle.ID = field.NewUint(tableName, "id")
+	_kostenstelle.CreatedAt = field.NewTime(tableName, "created_at")
+	_kostenstelle.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_kostenstelle.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_kostenstelle.fillFieldMap()
+
+	return _kostenstelle
+}
+
+type kostenstelle struct {
+	kostenstelleDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (k kostenstelle) Table(newTableName string) *kostenstelle {
+	k.kostenstelleDo.UseTable(newTableName)
+	return k.updateTableName(newTableName)
+}
+
+func (k kostenstelle) As(alias string) *kostenstelle {
+	k.kostenstelleDo.DO = *(k.kostenstelleDo.As(alias).(*gen.DO))
+	return k.updateTableName(alias)
+}
+
+func (k *kostenstelle) updateTableName(table string) *kostenstelle {
+	k.ALL = field.NewAsterisk(table)
+	k.ID = field.NewUint(table, "id")
+	k.CreatedAt = field.NewTime(table, "created_at")
+	k.UpdatedAt = field.NewTime(table, "updated_at")
+	k.DeletedAt = field.NewField(table, "deleted_at")
+
+	k.fillFieldMap()
+
+	return k
+}
+
+func (k *kostenstelle) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := k.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (k *kostenstelle) fillFieldMap() {
+	k.fieldMap = make(map[string]field.Expr, 4)
+	k.fieldMap["id"] = k.ID
+	k.fieldMap["created_at"] = k.CreatedAt
+	k.fieldMap["updated_at"] = k.UpdatedAt
+	k.fieldMap["deleted_at"] = k.DeletedAt
+}
+
+func (k kostenstelle) clone(db *gorm.DB) kostenstelle {
+	k.kostenstelleDo.ReplaceConnPool(db.Statement.ConnPool)
+	return k
+}
+
+func (k kostenstelle) replaceDB(db *gorm.DB) kostenstelle {
+	k.kostenstelleDo.ReplaceDB(db)
+	return k
+}
+
+type kostenstelleDo struct{ gen.DO }
+
+type IKostenstelleDo interface {
+	gen.SubQuery
+	Debug() IKostenstelleDo
+	WithContext(ctx context.Context) IKostenstelleDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IKostenstelleDo
+	WriteDB() IKostenstelleDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IKostenstelleDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IKostenstelleDo
+	Not(conds ...gen.Condition) IKostenstelleDo
+	Or(conds ...gen.Condition) IKostenstelleDo
+	Select(conds ...field.Expr) IKostenstelleDo
+	Where(conds ...gen.Condition) IKostenstelleDo
+	Order(conds ...field.Expr) IKostenstelleDo
+	Distinct(cols ...field.Expr) IKostenstelleDo
+	Omit(cols ...field.Expr) IKostenstelleDo
+	Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo
+	Group(cols ...field.Expr) IKostenstelleDo
+	Having(conds ...gen.Condition) IKostenstelleDo
+	Limit(limit int) IKostenstelleDo
+	Offset(offset int) IKostenstelleDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo
+	Unscoped() IKostenstelleDo
+	Create(values ...*model.Kostenstelle) error
+	CreateInBatches(values []*model.Kostenstelle, batchSize int) error
+	Save(values ...*model.Kostenstelle) error
+	First() (*model.Kostenstelle, error)
+	Take() (*model.Kostenstelle, error)
+	Last() (*model.Kostenstelle, error)
+	Find() ([]*model.Kostenstelle, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error)
+	FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Kostenstelle) (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) IKostenstelleDo
+	Assign(attrs ...field.AssignExpr) IKostenstelleDo
+	Joins(fields ...field.RelationField) IKostenstelleDo
+	Preload(fields ...field.RelationField) IKostenstelleDo
+	FirstOrInit() (*model.Kostenstelle, error)
+	FirstOrCreate() (*model.Kostenstelle, error)
+	FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IKostenstelleDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (k kostenstelleDo) Debug() IKostenstelleDo {
+	return k.withDO(k.DO.Debug())
+}
+
+func (k kostenstelleDo) WithContext(ctx context.Context) IKostenstelleDo {
+	return k.withDO(k.DO.WithContext(ctx))
+}
+
+func (k kostenstelleDo) ReadDB() IKostenstelleDo {
+	return k.Clauses(dbresolver.Read)
+}
+
+func (k kostenstelleDo) WriteDB() IKostenstelleDo {
+	return k.Clauses(dbresolver.Write)
+}
+
+func (k kostenstelleDo) Session(config *gorm.Session) IKostenstelleDo {
+	return k.withDO(k.DO.Session(config))
+}
+
+func (k kostenstelleDo) Clauses(conds ...clause.Expression) IKostenstelleDo {
+	return k.withDO(k.DO.Clauses(conds...))
+}
+
+func (k kostenstelleDo) Returning(value interface{}, columns ...string) IKostenstelleDo {
+	return k.withDO(k.DO.Returning(value, columns...))
+}
+
+func (k kostenstelleDo) Not(conds ...gen.Condition) IKostenstelleDo {
+	return k.withDO(k.DO.Not(conds...))
+}
+
+func (k kostenstelleDo) Or(conds ...gen.Condition) IKostenstelleDo {
+	return k.withDO(k.DO.Or(conds...))
+}
+
+func (k kostenstelleDo) Select(conds ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.Select(conds...))
+}
+
+func (k kostenstelleDo) Where(conds ...gen.Condition) IKostenstelleDo {
+	return k.withDO(k.DO.Where(conds...))
+}
+
+func (k kostenstelleDo) Order(conds ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.Order(conds...))
+}
+
+func (k kostenstelleDo) Distinct(cols ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.Distinct(cols...))
+}
+
+func (k kostenstelleDo) Omit(cols ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.Omit(cols...))
+}
+
+func (k kostenstelleDo) Join(table schema.Tabler, on ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.Join(table, on...))
+}
+
+func (k kostenstelleDo) LeftJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.LeftJoin(table, on...))
+}
+
+func (k kostenstelleDo) RightJoin(table schema.Tabler, on ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.RightJoin(table, on...))
+}
+
+func (k kostenstelleDo) Group(cols ...field.Expr) IKostenstelleDo {
+	return k.withDO(k.DO.Group(cols...))
+}
+
+func (k kostenstelleDo) Having(conds ...gen.Condition) IKostenstelleDo {
+	return k.withDO(k.DO.Having(conds...))
+}
+
+func (k kostenstelleDo) Limit(limit int) IKostenstelleDo {
+	return k.withDO(k.DO.Limit(limit))
+}
+
+func (k kostenstelleDo) Offset(offset int) IKostenstelleDo {
+	return k.withDO(k.DO.Offset(offset))
+}
+
+func (k kostenstelleDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IKostenstelleDo {
+	return k.withDO(k.DO.Scopes(funcs...))
+}
+
+func (k kostenstelleDo) Unscoped() IKostenstelleDo {
+	return k.withDO(k.DO.Unscoped())
+}
+
+func (k kostenstelleDo) Create(values ...*model.Kostenstelle) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return k.DO.Create(values)
+}
+
+func (k kostenstelleDo) CreateInBatches(values []*model.Kostenstelle, batchSize int) error {
+	return k.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 (k kostenstelleDo) Save(values ...*model.Kostenstelle) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return k.DO.Save(values)
+}
+
+func (k kostenstelleDo) First() (*model.Kostenstelle, error) {
+	if result, err := k.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kostenstelle), nil
+	}
+}
+
+func (k kostenstelleDo) Take() (*model.Kostenstelle, error) {
+	if result, err := k.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kostenstelle), nil
+	}
+}
+
+func (k kostenstelleDo) Last() (*model.Kostenstelle, error) {
+	if result, err := k.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kostenstelle), nil
+	}
+}
+
+func (k kostenstelleDo) Find() ([]*model.Kostenstelle, error) {
+	result, err := k.DO.Find()
+	return result.([]*model.Kostenstelle), err
+}
+
+func (k kostenstelleDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Kostenstelle, err error) {
+	buf := make([]*model.Kostenstelle, 0, batchSize)
+	err = k.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 (k kostenstelleDo) FindInBatches(result *[]*model.Kostenstelle, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return k.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (k kostenstelleDo) Attrs(attrs ...field.AssignExpr) IKostenstelleDo {
+	return k.withDO(k.DO.Attrs(attrs...))
+}
+
+func (k kostenstelleDo) Assign(attrs ...field.AssignExpr) IKostenstelleDo {
+	return k.withDO(k.DO.Assign(attrs...))
+}
+
+func (k kostenstelleDo) Joins(fields ...field.RelationField) IKostenstelleDo {
+	for _, _f := range fields {
+		k = *k.withDO(k.DO.Joins(_f))
+	}
+	return &k
+}
+
+func (k kostenstelleDo) Preload(fields ...field.RelationField) IKostenstelleDo {
+	for _, _f := range fields {
+		k = *k.withDO(k.DO.Preload(_f))
+	}
+	return &k
+}
+
+func (k kostenstelleDo) FirstOrInit() (*model.Kostenstelle, error) {
+	if result, err := k.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kostenstelle), nil
+	}
+}
+
+func (k kostenstelleDo) FirstOrCreate() (*model.Kostenstelle, error) {
+	if result, err := k.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Kostenstelle), nil
+	}
+}
+
+func (k kostenstelleDo) FindByPage(offset int, limit int) (result []*model.Kostenstelle, count int64, err error) {
+	result, err = k.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 = k.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (k kostenstelleDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = k.Count()
+	if err != nil {
+		return
+	}
+
+	err = k.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (k kostenstelleDo) Scan(result interface{}) (err error) {
+	return k.DO.Scan(result)
+}
+
+func (k kostenstelleDo) Delete(models ...*model.Kostenstelle) (result gen.ResultInfo, err error) {
+	return k.DO.Delete(models)
+}
+
+func (k *kostenstelleDo) withDO(do gen.Dao) *kostenstelleDo {
+	k.DO = *do.(*gen.DO)
+	return k
+}

query/lagerplatzs.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newLagerplatz(db *gorm.DB, opts ...gen.DOOption) lagerplatz {
+	_lagerplatz := lagerplatz{}
+
+	_lagerplatz.lagerplatzDo.UseDB(db, opts...)
+	_lagerplatz.lagerplatzDo.UseModel(&model.Lagerplatz{})
+
+	tableName := _lagerplatz.lagerplatzDo.TableName()
+	_lagerplatz.ALL = field.NewAsterisk(tableName)
+	_lagerplatz.ID = field.NewUint(tableName, "id")
+	_lagerplatz.CreatedAt = field.NewTime(tableName, "created_at")
+	_lagerplatz.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_lagerplatz.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_lagerplatz.fillFieldMap()
+
+	return _lagerplatz
+}
+
+type lagerplatz struct {
+	lagerplatzDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (l lagerplatz) Table(newTableName string) *lagerplatz {
+	l.lagerplatzDo.UseTable(newTableName)
+	return l.updateTableName(newTableName)
+}
+
+func (l lagerplatz) As(alias string) *lagerplatz {
+	l.lagerplatzDo.DO = *(l.lagerplatzDo.As(alias).(*gen.DO))
+	return l.updateTableName(alias)
+}
+
+func (l *lagerplatz) updateTableName(table string) *lagerplatz {
+	l.ALL = field.NewAsterisk(table)
+	l.ID = field.NewUint(table, "id")
+	l.CreatedAt = field.NewTime(table, "created_at")
+	l.UpdatedAt = field.NewTime(table, "updated_at")
+	l.DeletedAt = field.NewField(table, "deleted_at")
+
+	l.fillFieldMap()
+
+	return l
+}
+
+func (l *lagerplatz) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := l.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (l *lagerplatz) fillFieldMap() {
+	l.fieldMap = make(map[string]field.Expr, 4)
+	l.fieldMap["id"] = l.ID
+	l.fieldMap["created_at"] = l.CreatedAt
+	l.fieldMap["updated_at"] = l.UpdatedAt
+	l.fieldMap["deleted_at"] = l.DeletedAt
+}
+
+func (l lagerplatz) clone(db *gorm.DB) lagerplatz {
+	l.lagerplatzDo.ReplaceConnPool(db.Statement.ConnPool)
+	return l
+}
+
+func (l lagerplatz) replaceDB(db *gorm.DB) lagerplatz {
+	l.lagerplatzDo.ReplaceDB(db)
+	return l
+}
+
+type lagerplatzDo struct{ gen.DO }
+
+type ILagerplatzDo interface {
+	gen.SubQuery
+	Debug() ILagerplatzDo
+	WithContext(ctx context.Context) ILagerplatzDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() ILagerplatzDo
+	WriteDB() ILagerplatzDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) ILagerplatzDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) ILagerplatzDo
+	Not(conds ...gen.Condition) ILagerplatzDo
+	Or(conds ...gen.Condition) ILagerplatzDo
+	Select(conds ...field.Expr) ILagerplatzDo
+	Where(conds ...gen.Condition) ILagerplatzDo
+	Order(conds ...field.Expr) ILagerplatzDo
+	Distinct(cols ...field.Expr) ILagerplatzDo
+	Omit(cols ...field.Expr) ILagerplatzDo
+	Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo
+	RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo
+	Group(cols ...field.Expr) ILagerplatzDo
+	Having(conds ...gen.Condition) ILagerplatzDo
+	Limit(limit int) ILagerplatzDo
+	Offset(offset int) ILagerplatzDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo
+	Unscoped() ILagerplatzDo
+	Create(values ...*model.Lagerplatz) error
+	CreateInBatches(values []*model.Lagerplatz, batchSize int) error
+	Save(values ...*model.Lagerplatz) error
+	First() (*model.Lagerplatz, error)
+	Take() (*model.Lagerplatz, error)
+	Last() (*model.Lagerplatz, error)
+	Find() ([]*model.Lagerplatz, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error)
+	FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Lagerplatz) (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) ILagerplatzDo
+	Assign(attrs ...field.AssignExpr) ILagerplatzDo
+	Joins(fields ...field.RelationField) ILagerplatzDo
+	Preload(fields ...field.RelationField) ILagerplatzDo
+	FirstOrInit() (*model.Lagerplatz, error)
+	FirstOrCreate() (*model.Lagerplatz, error)
+	FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) ILagerplatzDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (l lagerplatzDo) Debug() ILagerplatzDo {
+	return l.withDO(l.DO.Debug())
+}
+
+func (l lagerplatzDo) WithContext(ctx context.Context) ILagerplatzDo {
+	return l.withDO(l.DO.WithContext(ctx))
+}
+
+func (l lagerplatzDo) ReadDB() ILagerplatzDo {
+	return l.Clauses(dbresolver.Read)
+}
+
+func (l lagerplatzDo) WriteDB() ILagerplatzDo {
+	return l.Clauses(dbresolver.Write)
+}
+
+func (l lagerplatzDo) Session(config *gorm.Session) ILagerplatzDo {
+	return l.withDO(l.DO.Session(config))
+}
+
+func (l lagerplatzDo) Clauses(conds ...clause.Expression) ILagerplatzDo {
+	return l.withDO(l.DO.Clauses(conds...))
+}
+
+func (l lagerplatzDo) Returning(value interface{}, columns ...string) ILagerplatzDo {
+	return l.withDO(l.DO.Returning(value, columns...))
+}
+
+func (l lagerplatzDo) Not(conds ...gen.Condition) ILagerplatzDo {
+	return l.withDO(l.DO.Not(conds...))
+}
+
+func (l lagerplatzDo) Or(conds ...gen.Condition) ILagerplatzDo {
+	return l.withDO(l.DO.Or(conds...))
+}
+
+func (l lagerplatzDo) Select(conds ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.Select(conds...))
+}
+
+func (l lagerplatzDo) Where(conds ...gen.Condition) ILagerplatzDo {
+	return l.withDO(l.DO.Where(conds...))
+}
+
+func (l lagerplatzDo) Order(conds ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.Order(conds...))
+}
+
+func (l lagerplatzDo) Distinct(cols ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.Distinct(cols...))
+}
+
+func (l lagerplatzDo) Omit(cols ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.Omit(cols...))
+}
+
+func (l lagerplatzDo) Join(table schema.Tabler, on ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.Join(table, on...))
+}
+
+func (l lagerplatzDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.LeftJoin(table, on...))
+}
+
+func (l lagerplatzDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.RightJoin(table, on...))
+}
+
+func (l lagerplatzDo) Group(cols ...field.Expr) ILagerplatzDo {
+	return l.withDO(l.DO.Group(cols...))
+}
+
+func (l lagerplatzDo) Having(conds ...gen.Condition) ILagerplatzDo {
+	return l.withDO(l.DO.Having(conds...))
+}
+
+func (l lagerplatzDo) Limit(limit int) ILagerplatzDo {
+	return l.withDO(l.DO.Limit(limit))
+}
+
+func (l lagerplatzDo) Offset(offset int) ILagerplatzDo {
+	return l.withDO(l.DO.Offset(offset))
+}
+
+func (l lagerplatzDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerplatzDo {
+	return l.withDO(l.DO.Scopes(funcs...))
+}
+
+func (l lagerplatzDo) Unscoped() ILagerplatzDo {
+	return l.withDO(l.DO.Unscoped())
+}
+
+func (l lagerplatzDo) Create(values ...*model.Lagerplatz) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Create(values)
+}
+
+func (l lagerplatzDo) CreateInBatches(values []*model.Lagerplatz, batchSize int) error {
+	return l.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 (l lagerplatzDo) Save(values ...*model.Lagerplatz) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Save(values)
+}
+
+func (l lagerplatzDo) First() (*model.Lagerplatz, error) {
+	if result, err := l.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lagerplatz), nil
+	}
+}
+
+func (l lagerplatzDo) Take() (*model.Lagerplatz, error) {
+	if result, err := l.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lagerplatz), nil
+	}
+}
+
+func (l lagerplatzDo) Last() (*model.Lagerplatz, error) {
+	if result, err := l.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lagerplatz), nil
+	}
+}
+
+func (l lagerplatzDo) Find() ([]*model.Lagerplatz, error) {
+	result, err := l.DO.Find()
+	return result.([]*model.Lagerplatz), err
+}
+
+func (l lagerplatzDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lagerplatz, err error) {
+	buf := make([]*model.Lagerplatz, 0, batchSize)
+	err = l.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 (l lagerplatzDo) FindInBatches(result *[]*model.Lagerplatz, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return l.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (l lagerplatzDo) Attrs(attrs ...field.AssignExpr) ILagerplatzDo {
+	return l.withDO(l.DO.Attrs(attrs...))
+}
+
+func (l lagerplatzDo) Assign(attrs ...field.AssignExpr) ILagerplatzDo {
+	return l.withDO(l.DO.Assign(attrs...))
+}
+
+func (l lagerplatzDo) Joins(fields ...field.RelationField) ILagerplatzDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Joins(_f))
+	}
+	return &l
+}
+
+func (l lagerplatzDo) Preload(fields ...field.RelationField) ILagerplatzDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Preload(_f))
+	}
+	return &l
+}
+
+func (l lagerplatzDo) FirstOrInit() (*model.Lagerplatz, error) {
+	if result, err := l.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lagerplatz), nil
+	}
+}
+
+func (l lagerplatzDo) FirstOrCreate() (*model.Lagerplatz, error) {
+	if result, err := l.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lagerplatz), nil
+	}
+}
+
+func (l lagerplatzDo) FindByPage(offset int, limit int) (result []*model.Lagerplatz, count int64, err error) {
+	result, err = l.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 = l.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (l lagerplatzDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = l.Count()
+	if err != nil {
+		return
+	}
+
+	err = l.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (l lagerplatzDo) Scan(result interface{}) (err error) {
+	return l.DO.Scan(result)
+}
+
+func (l lagerplatzDo) Delete(models ...*model.Lagerplatz) (result gen.ResultInfo, err error) {
+	return l.DO.Delete(models)
+}
+
+func (l *lagerplatzDo) withDO(do gen.Dao) *lagerplatzDo {
+	l.DO = *do.(*gen.DO)
+	return l
+}

query/lagers.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newLager(db *gorm.DB, opts ...gen.DOOption) lager {
+	_lager := lager{}
+
+	_lager.lagerDo.UseDB(db, opts...)
+	_lager.lagerDo.UseModel(&model.Lager{})
+
+	tableName := _lager.lagerDo.TableName()
+	_lager.ALL = field.NewAsterisk(tableName)
+	_lager.ID = field.NewUint(tableName, "id")
+	_lager.CreatedAt = field.NewTime(tableName, "created_at")
+	_lager.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_lager.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_lager.fillFieldMap()
+
+	return _lager
+}
+
+type lager struct {
+	lagerDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (l lager) Table(newTableName string) *lager {
+	l.lagerDo.UseTable(newTableName)
+	return l.updateTableName(newTableName)
+}
+
+func (l lager) As(alias string) *lager {
+	l.lagerDo.DO = *(l.lagerDo.As(alias).(*gen.DO))
+	return l.updateTableName(alias)
+}
+
+func (l *lager) updateTableName(table string) *lager {
+	l.ALL = field.NewAsterisk(table)
+	l.ID = field.NewUint(table, "id")
+	l.CreatedAt = field.NewTime(table, "created_at")
+	l.UpdatedAt = field.NewTime(table, "updated_at")
+	l.DeletedAt = field.NewField(table, "deleted_at")
+
+	l.fillFieldMap()
+
+	return l
+}
+
+func (l *lager) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := l.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (l *lager) fillFieldMap() {
+	l.fieldMap = make(map[string]field.Expr, 4)
+	l.fieldMap["id"] = l.ID
+	l.fieldMap["created_at"] = l.CreatedAt
+	l.fieldMap["updated_at"] = l.UpdatedAt
+	l.fieldMap["deleted_at"] = l.DeletedAt
+}
+
+func (l lager) clone(db *gorm.DB) lager {
+	l.lagerDo.ReplaceConnPool(db.Statement.ConnPool)
+	return l
+}
+
+func (l lager) replaceDB(db *gorm.DB) lager {
+	l.lagerDo.ReplaceDB(db)
+	return l
+}
+
+type lagerDo struct{ gen.DO }
+
+type ILagerDo interface {
+	gen.SubQuery
+	Debug() ILagerDo
+	WithContext(ctx context.Context) ILagerDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() ILagerDo
+	WriteDB() ILagerDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) ILagerDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) ILagerDo
+	Not(conds ...gen.Condition) ILagerDo
+	Or(conds ...gen.Condition) ILagerDo
+	Select(conds ...field.Expr) ILagerDo
+	Where(conds ...gen.Condition) ILagerDo
+	Order(conds ...field.Expr) ILagerDo
+	Distinct(cols ...field.Expr) ILagerDo
+	Omit(cols ...field.Expr) ILagerDo
+	Join(table schema.Tabler, on ...field.Expr) ILagerDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo
+	RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo
+	Group(cols ...field.Expr) ILagerDo
+	Having(conds ...gen.Condition) ILagerDo
+	Limit(limit int) ILagerDo
+	Offset(offset int) ILagerDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo
+	Unscoped() ILagerDo
+	Create(values ...*model.Lager) error
+	CreateInBatches(values []*model.Lager, batchSize int) error
+	Save(values ...*model.Lager) error
+	First() (*model.Lager, error)
+	Take() (*model.Lager, error)
+	Last() (*model.Lager, error)
+	Find() ([]*model.Lager, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error)
+	FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Lager) (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) ILagerDo
+	Assign(attrs ...field.AssignExpr) ILagerDo
+	Joins(fields ...field.RelationField) ILagerDo
+	Preload(fields ...field.RelationField) ILagerDo
+	FirstOrInit() (*model.Lager, error)
+	FirstOrCreate() (*model.Lager, error)
+	FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) ILagerDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (l lagerDo) Debug() ILagerDo {
+	return l.withDO(l.DO.Debug())
+}
+
+func (l lagerDo) WithContext(ctx context.Context) ILagerDo {
+	return l.withDO(l.DO.WithContext(ctx))
+}
+
+func (l lagerDo) ReadDB() ILagerDo {
+	return l.Clauses(dbresolver.Read)
+}
+
+func (l lagerDo) WriteDB() ILagerDo {
+	return l.Clauses(dbresolver.Write)
+}
+
+func (l lagerDo) Session(config *gorm.Session) ILagerDo {
+	return l.withDO(l.DO.Session(config))
+}
+
+func (l lagerDo) Clauses(conds ...clause.Expression) ILagerDo {
+	return l.withDO(l.DO.Clauses(conds...))
+}
+
+func (l lagerDo) Returning(value interface{}, columns ...string) ILagerDo {
+	return l.withDO(l.DO.Returning(value, columns...))
+}
+
+func (l lagerDo) Not(conds ...gen.Condition) ILagerDo {
+	return l.withDO(l.DO.Not(conds...))
+}
+
+func (l lagerDo) Or(conds ...gen.Condition) ILagerDo {
+	return l.withDO(l.DO.Or(conds...))
+}
+
+func (l lagerDo) Select(conds ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.Select(conds...))
+}
+
+func (l lagerDo) Where(conds ...gen.Condition) ILagerDo {
+	return l.withDO(l.DO.Where(conds...))
+}
+
+func (l lagerDo) Order(conds ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.Order(conds...))
+}
+
+func (l lagerDo) Distinct(cols ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.Distinct(cols...))
+}
+
+func (l lagerDo) Omit(cols ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.Omit(cols...))
+}
+
+func (l lagerDo) Join(table schema.Tabler, on ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.Join(table, on...))
+}
+
+func (l lagerDo) LeftJoin(table schema.Tabler, on ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.LeftJoin(table, on...))
+}
+
+func (l lagerDo) RightJoin(table schema.Tabler, on ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.RightJoin(table, on...))
+}
+
+func (l lagerDo) Group(cols ...field.Expr) ILagerDo {
+	return l.withDO(l.DO.Group(cols...))
+}
+
+func (l lagerDo) Having(conds ...gen.Condition) ILagerDo {
+	return l.withDO(l.DO.Having(conds...))
+}
+
+func (l lagerDo) Limit(limit int) ILagerDo {
+	return l.withDO(l.DO.Limit(limit))
+}
+
+func (l lagerDo) Offset(offset int) ILagerDo {
+	return l.withDO(l.DO.Offset(offset))
+}
+
+func (l lagerDo) Scopes(funcs ...func(gen.Dao) gen.Dao) ILagerDo {
+	return l.withDO(l.DO.Scopes(funcs...))
+}
+
+func (l lagerDo) Unscoped() ILagerDo {
+	return l.withDO(l.DO.Unscoped())
+}
+
+func (l lagerDo) Create(values ...*model.Lager) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Create(values)
+}
+
+func (l lagerDo) CreateInBatches(values []*model.Lager, batchSize int) error {
+	return l.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 (l lagerDo) Save(values ...*model.Lager) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return l.DO.Save(values)
+}
+
+func (l lagerDo) First() (*model.Lager, error) {
+	if result, err := l.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lager), nil
+	}
+}
+
+func (l lagerDo) Take() (*model.Lager, error) {
+	if result, err := l.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lager), nil
+	}
+}
+
+func (l lagerDo) Last() (*model.Lager, error) {
+	if result, err := l.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lager), nil
+	}
+}
+
+func (l lagerDo) Find() ([]*model.Lager, error) {
+	result, err := l.DO.Find()
+	return result.([]*model.Lager), err
+}
+
+func (l lagerDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Lager, err error) {
+	buf := make([]*model.Lager, 0, batchSize)
+	err = l.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 (l lagerDo) FindInBatches(result *[]*model.Lager, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return l.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (l lagerDo) Attrs(attrs ...field.AssignExpr) ILagerDo {
+	return l.withDO(l.DO.Attrs(attrs...))
+}
+
+func (l lagerDo) Assign(attrs ...field.AssignExpr) ILagerDo {
+	return l.withDO(l.DO.Assign(attrs...))
+}
+
+func (l lagerDo) Joins(fields ...field.RelationField) ILagerDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Joins(_f))
+	}
+	return &l
+}
+
+func (l lagerDo) Preload(fields ...field.RelationField) ILagerDo {
+	for _, _f := range fields {
+		l = *l.withDO(l.DO.Preload(_f))
+	}
+	return &l
+}
+
+func (l lagerDo) FirstOrInit() (*model.Lager, error) {
+	if result, err := l.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lager), nil
+	}
+}
+
+func (l lagerDo) FirstOrCreate() (*model.Lager, error) {
+	if result, err := l.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Lager), nil
+	}
+}
+
+func (l lagerDo) FindByPage(offset int, limit int) (result []*model.Lager, count int64, err error) {
+	result, err = l.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 = l.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (l lagerDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = l.Count()
+	if err != nil {
+		return
+	}
+
+	err = l.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (l lagerDo) Scan(result interface{}) (err error) {
+	return l.DO.Scan(result)
+}
+
+func (l lagerDo) Delete(models ...*model.Lager) (result gen.ResultInfo, err error) {
+	return l.DO.Delete(models)
+}
+
+func (l *lagerDo) withDO(do gen.Dao) *lagerDo {
+	l.DO = *do.(*gen.DO)
+	return l
+}

query/materials.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newMaterial(db *gorm.DB, opts ...gen.DOOption) material {
+	_material := material{}
+
+	_material.materialDo.UseDB(db, opts...)
+	_material.materialDo.UseModel(&model.Material{})
+
+	tableName := _material.materialDo.TableName()
+	_material.ALL = field.NewAsterisk(tableName)
+	_material.ID = field.NewUint(tableName, "id")
+	_material.CreatedAt = field.NewTime(tableName, "created_at")
+	_material.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_material.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_material.fillFieldMap()
+
+	return _material
+}
+
+type material struct {
+	materialDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (m material) Table(newTableName string) *material {
+	m.materialDo.UseTable(newTableName)
+	return m.updateTableName(newTableName)
+}
+
+func (m material) As(alias string) *material {
+	m.materialDo.DO = *(m.materialDo.As(alias).(*gen.DO))
+	return m.updateTableName(alias)
+}
+
+func (m *material) updateTableName(table string) *material {
+	m.ALL = field.NewAsterisk(table)
+	m.ID = field.NewUint(table, "id")
+	m.CreatedAt = field.NewTime(table, "created_at")
+	m.UpdatedAt = field.NewTime(table, "updated_at")
+	m.DeletedAt = field.NewField(table, "deleted_at")
+
+	m.fillFieldMap()
+
+	return m
+}
+
+func (m *material) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := m.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (m *material) fillFieldMap() {
+	m.fieldMap = make(map[string]field.Expr, 4)
+	m.fieldMap["id"] = m.ID
+	m.fieldMap["created_at"] = m.CreatedAt
+	m.fieldMap["updated_at"] = m.UpdatedAt
+	m.fieldMap["deleted_at"] = m.DeletedAt
+}
+
+func (m material) clone(db *gorm.DB) material {
+	m.materialDo.ReplaceConnPool(db.Statement.ConnPool)
+	return m
+}
+
+func (m material) replaceDB(db *gorm.DB) material {
+	m.materialDo.ReplaceDB(db)
+	return m
+}
+
+type materialDo struct{ gen.DO }
+
+type IMaterialDo interface {
+	gen.SubQuery
+	Debug() IMaterialDo
+	WithContext(ctx context.Context) IMaterialDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IMaterialDo
+	WriteDB() IMaterialDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IMaterialDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IMaterialDo
+	Not(conds ...gen.Condition) IMaterialDo
+	Or(conds ...gen.Condition) IMaterialDo
+	Select(conds ...field.Expr) IMaterialDo
+	Where(conds ...gen.Condition) IMaterialDo
+	Order(conds ...field.Expr) IMaterialDo
+	Distinct(cols ...field.Expr) IMaterialDo
+	Omit(cols ...field.Expr) IMaterialDo
+	Join(table schema.Tabler, on ...field.Expr) IMaterialDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo
+	Group(cols ...field.Expr) IMaterialDo
+	Having(conds ...gen.Condition) IMaterialDo
+	Limit(limit int) IMaterialDo
+	Offset(offset int) IMaterialDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo
+	Unscoped() IMaterialDo
+	Create(values ...*model.Material) error
+	CreateInBatches(values []*model.Material, batchSize int) error
+	Save(values ...*model.Material) error
+	First() (*model.Material, error)
+	Take() (*model.Material, error)
+	Last() (*model.Material, error)
+	Find() ([]*model.Material, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error)
+	FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Material) (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) IMaterialDo
+	Assign(attrs ...field.AssignExpr) IMaterialDo
+	Joins(fields ...field.RelationField) IMaterialDo
+	Preload(fields ...field.RelationField) IMaterialDo
+	FirstOrInit() (*model.Material, error)
+	FirstOrCreate() (*model.Material, error)
+	FindByPage(offset int, limit int) (result []*model.Material, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IMaterialDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (m materialDo) Debug() IMaterialDo {
+	return m.withDO(m.DO.Debug())
+}
+
+func (m materialDo) WithContext(ctx context.Context) IMaterialDo {
+	return m.withDO(m.DO.WithContext(ctx))
+}
+
+func (m materialDo) ReadDB() IMaterialDo {
+	return m.Clauses(dbresolver.Read)
+}
+
+func (m materialDo) WriteDB() IMaterialDo {
+	return m.Clauses(dbresolver.Write)
+}
+
+func (m materialDo) Session(config *gorm.Session) IMaterialDo {
+	return m.withDO(m.DO.Session(config))
+}
+
+func (m materialDo) Clauses(conds ...clause.Expression) IMaterialDo {
+	return m.withDO(m.DO.Clauses(conds...))
+}
+
+func (m materialDo) Returning(value interface{}, columns ...string) IMaterialDo {
+	return m.withDO(m.DO.Returning(value, columns...))
+}
+
+func (m materialDo) Not(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Not(conds...))
+}
+
+func (m materialDo) Or(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Or(conds...))
+}
+
+func (m materialDo) Select(conds ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Select(conds...))
+}
+
+func (m materialDo) Where(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Where(conds...))
+}
+
+func (m materialDo) Order(conds ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Order(conds...))
+}
+
+func (m materialDo) Distinct(cols ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Distinct(cols...))
+}
+
+func (m materialDo) Omit(cols ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Omit(cols...))
+}
+
+func (m materialDo) Join(table schema.Tabler, on ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Join(table, on...))
+}
+
+func (m materialDo) LeftJoin(table schema.Tabler, on ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.LeftJoin(table, on...))
+}
+
+func (m materialDo) RightJoin(table schema.Tabler, on ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.RightJoin(table, on...))
+}
+
+func (m materialDo) Group(cols ...field.Expr) IMaterialDo {
+	return m.withDO(m.DO.Group(cols...))
+}
+
+func (m materialDo) Having(conds ...gen.Condition) IMaterialDo {
+	return m.withDO(m.DO.Having(conds...))
+}
+
+func (m materialDo) Limit(limit int) IMaterialDo {
+	return m.withDO(m.DO.Limit(limit))
+}
+
+func (m materialDo) Offset(offset int) IMaterialDo {
+	return m.withDO(m.DO.Offset(offset))
+}
+
+func (m materialDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IMaterialDo {
+	return m.withDO(m.DO.Scopes(funcs...))
+}
+
+func (m materialDo) Unscoped() IMaterialDo {
+	return m.withDO(m.DO.Unscoped())
+}
+
+func (m materialDo) Create(values ...*model.Material) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return m.DO.Create(values)
+}
+
+func (m materialDo) CreateInBatches(values []*model.Material, batchSize int) error {
+	return m.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 (m materialDo) Save(values ...*model.Material) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return m.DO.Save(values)
+}
+
+func (m materialDo) First() (*model.Material, error) {
+	if result, err := m.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Material), nil
+	}
+}
+
+func (m materialDo) Take() (*model.Material, error) {
+	if result, err := m.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Material), nil
+	}
+}
+
+func (m materialDo) Last() (*model.Material, error) {
+	if result, err := m.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Material), nil
+	}
+}
+
+func (m materialDo) Find() ([]*model.Material, error) {
+	result, err := m.DO.Find()
+	return result.([]*model.Material), err
+}
+
+func (m materialDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Material, err error) {
+	buf := make([]*model.Material, 0, batchSize)
+	err = m.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 (m materialDo) FindInBatches(result *[]*model.Material, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return m.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (m materialDo) Attrs(attrs ...field.AssignExpr) IMaterialDo {
+	return m.withDO(m.DO.Attrs(attrs...))
+}
+
+func (m materialDo) Assign(attrs ...field.AssignExpr) IMaterialDo {
+	return m.withDO(m.DO.Assign(attrs...))
+}
+
+func (m materialDo) Joins(fields ...field.RelationField) IMaterialDo {
+	for _, _f := range fields {
+		m = *m.withDO(m.DO.Joins(_f))
+	}
+	return &m
+}
+
+func (m materialDo) Preload(fields ...field.RelationField) IMaterialDo {
+	for _, _f := range fields {
+		m = *m.withDO(m.DO.Preload(_f))
+	}
+	return &m
+}
+
+func (m materialDo) FirstOrInit() (*model.Material, error) {
+	if result, err := m.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Material), nil
+	}
+}
+
+func (m materialDo) FirstOrCreate() (*model.Material, error) {
+	if result, err := m.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Material), nil
+	}
+}
+
+func (m materialDo) FindByPage(offset int, limit int) (result []*model.Material, count int64, err error) {
+	result, err = m.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 = m.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (m materialDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = m.Count()
+	if err != nil {
+		return
+	}
+
+	err = m.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (m materialDo) Scan(result interface{}) (err error) {
+	return m.DO.Scan(result)
+}
+
+func (m materialDo) Delete(models ...*model.Material) (result gen.ResultInfo, err error) {
+	return m.DO.Delete(models)
+}
+
+func (m *materialDo) withDO(do gen.Dao) *materialDo {
+	m.DO = *do.(*gen.DO)
+	return m
+}

query/nachrichts.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newNachricht(db *gorm.DB, opts ...gen.DOOption) nachricht {
+	_nachricht := nachricht{}
+
+	_nachricht.nachrichtDo.UseDB(db, opts...)
+	_nachricht.nachrichtDo.UseModel(&model.Nachricht{})
+
+	tableName := _nachricht.nachrichtDo.TableName()
+	_nachricht.ALL = field.NewAsterisk(tableName)
+	_nachricht.ID = field.NewUint(tableName, "id")
+	_nachricht.CreatedAt = field.NewTime(tableName, "created_at")
+	_nachricht.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_nachricht.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_nachricht.fillFieldMap()
+
+	return _nachricht
+}
+
+type nachricht struct {
+	nachrichtDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (n nachricht) Table(newTableName string) *nachricht {
+	n.nachrichtDo.UseTable(newTableName)
+	return n.updateTableName(newTableName)
+}
+
+func (n nachricht) As(alias string) *nachricht {
+	n.nachrichtDo.DO = *(n.nachrichtDo.As(alias).(*gen.DO))
+	return n.updateTableName(alias)
+}
+
+func (n *nachricht) updateTableName(table string) *nachricht {
+	n.ALL = field.NewAsterisk(table)
+	n.ID = field.NewUint(table, "id")
+	n.CreatedAt = field.NewTime(table, "created_at")
+	n.UpdatedAt = field.NewTime(table, "updated_at")
+	n.DeletedAt = field.NewField(table, "deleted_at")
+
+	n.fillFieldMap()
+
+	return n
+}
+
+func (n *nachricht) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := n.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (n *nachricht) fillFieldMap() {
+	n.fieldMap = make(map[string]field.Expr, 4)
+	n.fieldMap["id"] = n.ID
+	n.fieldMap["created_at"] = n.CreatedAt
+	n.fieldMap["updated_at"] = n.UpdatedAt
+	n.fieldMap["deleted_at"] = n.DeletedAt
+}
+
+func (n nachricht) clone(db *gorm.DB) nachricht {
+	n.nachrichtDo.ReplaceConnPool(db.Statement.ConnPool)
+	return n
+}
+
+func (n nachricht) replaceDB(db *gorm.DB) nachricht {
+	n.nachrichtDo.ReplaceDB(db)
+	return n
+}
+
+type nachrichtDo struct{ gen.DO }
+
+type INachrichtDo interface {
+	gen.SubQuery
+	Debug() INachrichtDo
+	WithContext(ctx context.Context) INachrichtDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() INachrichtDo
+	WriteDB() INachrichtDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) INachrichtDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) INachrichtDo
+	Not(conds ...gen.Condition) INachrichtDo
+	Or(conds ...gen.Condition) INachrichtDo
+	Select(conds ...field.Expr) INachrichtDo
+	Where(conds ...gen.Condition) INachrichtDo
+	Order(conds ...field.Expr) INachrichtDo
+	Distinct(cols ...field.Expr) INachrichtDo
+	Omit(cols ...field.Expr) INachrichtDo
+	Join(table schema.Tabler, on ...field.Expr) INachrichtDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo
+	RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo
+	Group(cols ...field.Expr) INachrichtDo
+	Having(conds ...gen.Condition) INachrichtDo
+	Limit(limit int) INachrichtDo
+	Offset(offset int) INachrichtDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo
+	Unscoped() INachrichtDo
+	Create(values ...*model.Nachricht) error
+	CreateInBatches(values []*model.Nachricht, batchSize int) error
+	Save(values ...*model.Nachricht) error
+	First() (*model.Nachricht, error)
+	Take() (*model.Nachricht, error)
+	Last() (*model.Nachricht, error)
+	Find() ([]*model.Nachricht, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error)
+	FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Nachricht) (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) INachrichtDo
+	Assign(attrs ...field.AssignExpr) INachrichtDo
+	Joins(fields ...field.RelationField) INachrichtDo
+	Preload(fields ...field.RelationField) INachrichtDo
+	FirstOrInit() (*model.Nachricht, error)
+	FirstOrCreate() (*model.Nachricht, error)
+	FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) INachrichtDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (n nachrichtDo) Debug() INachrichtDo {
+	return n.withDO(n.DO.Debug())
+}
+
+func (n nachrichtDo) WithContext(ctx context.Context) INachrichtDo {
+	return n.withDO(n.DO.WithContext(ctx))
+}
+
+func (n nachrichtDo) ReadDB() INachrichtDo {
+	return n.Clauses(dbresolver.Read)
+}
+
+func (n nachrichtDo) WriteDB() INachrichtDo {
+	return n.Clauses(dbresolver.Write)
+}
+
+func (n nachrichtDo) Session(config *gorm.Session) INachrichtDo {
+	return n.withDO(n.DO.Session(config))
+}
+
+func (n nachrichtDo) Clauses(conds ...clause.Expression) INachrichtDo {
+	return n.withDO(n.DO.Clauses(conds...))
+}
+
+func (n nachrichtDo) Returning(value interface{}, columns ...string) INachrichtDo {
+	return n.withDO(n.DO.Returning(value, columns...))
+}
+
+func (n nachrichtDo) Not(conds ...gen.Condition) INachrichtDo {
+	return n.withDO(n.DO.Not(conds...))
+}
+
+func (n nachrichtDo) Or(conds ...gen.Condition) INachrichtDo {
+	return n.withDO(n.DO.Or(conds...))
+}
+
+func (n nachrichtDo) Select(conds ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.Select(conds...))
+}
+
+func (n nachrichtDo) Where(conds ...gen.Condition) INachrichtDo {
+	return n.withDO(n.DO.Where(conds...))
+}
+
+func (n nachrichtDo) Order(conds ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.Order(conds...))
+}
+
+func (n nachrichtDo) Distinct(cols ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.Distinct(cols...))
+}
+
+func (n nachrichtDo) Omit(cols ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.Omit(cols...))
+}
+
+func (n nachrichtDo) Join(table schema.Tabler, on ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.Join(table, on...))
+}
+
+func (n nachrichtDo) LeftJoin(table schema.Tabler, on ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.LeftJoin(table, on...))
+}
+
+func (n nachrichtDo) RightJoin(table schema.Tabler, on ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.RightJoin(table, on...))
+}
+
+func (n nachrichtDo) Group(cols ...field.Expr) INachrichtDo {
+	return n.withDO(n.DO.Group(cols...))
+}
+
+func (n nachrichtDo) Having(conds ...gen.Condition) INachrichtDo {
+	return n.withDO(n.DO.Having(conds...))
+}
+
+func (n nachrichtDo) Limit(limit int) INachrichtDo {
+	return n.withDO(n.DO.Limit(limit))
+}
+
+func (n nachrichtDo) Offset(offset int) INachrichtDo {
+	return n.withDO(n.DO.Offset(offset))
+}
+
+func (n nachrichtDo) Scopes(funcs ...func(gen.Dao) gen.Dao) INachrichtDo {
+	return n.withDO(n.DO.Scopes(funcs...))
+}
+
+func (n nachrichtDo) Unscoped() INachrichtDo {
+	return n.withDO(n.DO.Unscoped())
+}
+
+func (n nachrichtDo) Create(values ...*model.Nachricht) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return n.DO.Create(values)
+}
+
+func (n nachrichtDo) CreateInBatches(values []*model.Nachricht, batchSize int) error {
+	return n.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 (n nachrichtDo) Save(values ...*model.Nachricht) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return n.DO.Save(values)
+}
+
+func (n nachrichtDo) First() (*model.Nachricht, error) {
+	if result, err := n.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Nachricht), nil
+	}
+}
+
+func (n nachrichtDo) Take() (*model.Nachricht, error) {
+	if result, err := n.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Nachricht), nil
+	}
+}
+
+func (n nachrichtDo) Last() (*model.Nachricht, error) {
+	if result, err := n.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Nachricht), nil
+	}
+}
+
+func (n nachrichtDo) Find() ([]*model.Nachricht, error) {
+	result, err := n.DO.Find()
+	return result.([]*model.Nachricht), err
+}
+
+func (n nachrichtDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Nachricht, err error) {
+	buf := make([]*model.Nachricht, 0, batchSize)
+	err = n.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 (n nachrichtDo) FindInBatches(result *[]*model.Nachricht, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return n.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (n nachrichtDo) Attrs(attrs ...field.AssignExpr) INachrichtDo {
+	return n.withDO(n.DO.Attrs(attrs...))
+}
+
+func (n nachrichtDo) Assign(attrs ...field.AssignExpr) INachrichtDo {
+	return n.withDO(n.DO.Assign(attrs...))
+}
+
+func (n nachrichtDo) Joins(fields ...field.RelationField) INachrichtDo {
+	for _, _f := range fields {
+		n = *n.withDO(n.DO.Joins(_f))
+	}
+	return &n
+}
+
+func (n nachrichtDo) Preload(fields ...field.RelationField) INachrichtDo {
+	for _, _f := range fields {
+		n = *n.withDO(n.DO.Preload(_f))
+	}
+	return &n
+}
+
+func (n nachrichtDo) FirstOrInit() (*model.Nachricht, error) {
+	if result, err := n.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Nachricht), nil
+	}
+}
+
+func (n nachrichtDo) FirstOrCreate() (*model.Nachricht, error) {
+	if result, err := n.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Nachricht), nil
+	}
+}
+
+func (n nachrichtDo) FindByPage(offset int, limit int) (result []*model.Nachricht, count int64, err error) {
+	result, err = n.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 = n.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (n nachrichtDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = n.Count()
+	if err != nil {
+		return
+	}
+
+	err = n.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (n nachrichtDo) Scan(result interface{}) (err error) {
+	return n.DO.Scan(result)
+}
+
+func (n nachrichtDo) Delete(models ...*model.Nachricht) (result gen.ResultInfo, err error) {
+	return n.DO.Delete(models)
+}
+
+func (n *nachrichtDo) withDO(do gen.Dao) *nachrichtDo {
+	n.DO = *do.(*gen.DO)
+	return n
+}

query/projekts.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newProjekt(db *gorm.DB, opts ...gen.DOOption) projekt {
+	_projekt := projekt{}
+
+	_projekt.projektDo.UseDB(db, opts...)
+	_projekt.projektDo.UseModel(&model.Projekt{})
+
+	tableName := _projekt.projektDo.TableName()
+	_projekt.ALL = field.NewAsterisk(tableName)
+	_projekt.ID = field.NewUint(tableName, "id")
+	_projekt.CreatedAt = field.NewTime(tableName, "created_at")
+	_projekt.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_projekt.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_projekt.fillFieldMap()
+
+	return _projekt
+}
+
+type projekt struct {
+	projektDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (p projekt) Table(newTableName string) *projekt {
+	p.projektDo.UseTable(newTableName)
+	return p.updateTableName(newTableName)
+}
+
+func (p projekt) As(alias string) *projekt {
+	p.projektDo.DO = *(p.projektDo.As(alias).(*gen.DO))
+	return p.updateTableName(alias)
+}
+
+func (p *projekt) updateTableName(table string) *projekt {
+	p.ALL = field.NewAsterisk(table)
+	p.ID = field.NewUint(table, "id")
+	p.CreatedAt = field.NewTime(table, "created_at")
+	p.UpdatedAt = field.NewTime(table, "updated_at")
+	p.DeletedAt = field.NewField(table, "deleted_at")
+
+	p.fillFieldMap()
+
+	return p
+}
+
+func (p *projekt) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := p.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (p *projekt) fillFieldMap() {
+	p.fieldMap = make(map[string]field.Expr, 4)
+	p.fieldMap["id"] = p.ID
+	p.fieldMap["created_at"] = p.CreatedAt
+	p.fieldMap["updated_at"] = p.UpdatedAt
+	p.fieldMap["deleted_at"] = p.DeletedAt
+}
+
+func (p projekt) clone(db *gorm.DB) projekt {
+	p.projektDo.ReplaceConnPool(db.Statement.ConnPool)
+	return p
+}
+
+func (p projekt) replaceDB(db *gorm.DB) projekt {
+	p.projektDo.ReplaceDB(db)
+	return p
+}
+
+type projektDo struct{ gen.DO }
+
+type IProjektDo interface {
+	gen.SubQuery
+	Debug() IProjektDo
+	WithContext(ctx context.Context) IProjektDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IProjektDo
+	WriteDB() IProjektDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IProjektDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IProjektDo
+	Not(conds ...gen.Condition) IProjektDo
+	Or(conds ...gen.Condition) IProjektDo
+	Select(conds ...field.Expr) IProjektDo
+	Where(conds ...gen.Condition) IProjektDo
+	Order(conds ...field.Expr) IProjektDo
+	Distinct(cols ...field.Expr) IProjektDo
+	Omit(cols ...field.Expr) IProjektDo
+	Join(table schema.Tabler, on ...field.Expr) IProjektDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo
+	Group(cols ...field.Expr) IProjektDo
+	Having(conds ...gen.Condition) IProjektDo
+	Limit(limit int) IProjektDo
+	Offset(offset int) IProjektDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo
+	Unscoped() IProjektDo
+	Create(values ...*model.Projekt) error
+	CreateInBatches(values []*model.Projekt, batchSize int) error
+	Save(values ...*model.Projekt) error
+	First() (*model.Projekt, error)
+	Take() (*model.Projekt, error)
+	Last() (*model.Projekt, error)
+	Find() ([]*model.Projekt, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error)
+	FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Projekt) (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) IProjektDo
+	Assign(attrs ...field.AssignExpr) IProjektDo
+	Joins(fields ...field.RelationField) IProjektDo
+	Preload(fields ...field.RelationField) IProjektDo
+	FirstOrInit() (*model.Projekt, error)
+	FirstOrCreate() (*model.Projekt, error)
+	FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IProjektDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (p projektDo) Debug() IProjektDo {
+	return p.withDO(p.DO.Debug())
+}
+
+func (p projektDo) WithContext(ctx context.Context) IProjektDo {
+	return p.withDO(p.DO.WithContext(ctx))
+}
+
+func (p projektDo) ReadDB() IProjektDo {
+	return p.Clauses(dbresolver.Read)
+}
+
+func (p projektDo) WriteDB() IProjektDo {
+	return p.Clauses(dbresolver.Write)
+}
+
+func (p projektDo) Session(config *gorm.Session) IProjektDo {
+	return p.withDO(p.DO.Session(config))
+}
+
+func (p projektDo) Clauses(conds ...clause.Expression) IProjektDo {
+	return p.withDO(p.DO.Clauses(conds...))
+}
+
+func (p projektDo) Returning(value interface{}, columns ...string) IProjektDo {
+	return p.withDO(p.DO.Returning(value, columns...))
+}
+
+func (p projektDo) Not(conds ...gen.Condition) IProjektDo {
+	return p.withDO(p.DO.Not(conds...))
+}
+
+func (p projektDo) Or(conds ...gen.Condition) IProjektDo {
+	return p.withDO(p.DO.Or(conds...))
+}
+
+func (p projektDo) Select(conds ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.Select(conds...))
+}
+
+func (p projektDo) Where(conds ...gen.Condition) IProjektDo {
+	return p.withDO(p.DO.Where(conds...))
+}
+
+func (p projektDo) Order(conds ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.Order(conds...))
+}
+
+func (p projektDo) Distinct(cols ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.Distinct(cols...))
+}
+
+func (p projektDo) Omit(cols ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.Omit(cols...))
+}
+
+func (p projektDo) Join(table schema.Tabler, on ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.Join(table, on...))
+}
+
+func (p projektDo) LeftJoin(table schema.Tabler, on ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.LeftJoin(table, on...))
+}
+
+func (p projektDo) RightJoin(table schema.Tabler, on ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.RightJoin(table, on...))
+}
+
+func (p projektDo) Group(cols ...field.Expr) IProjektDo {
+	return p.withDO(p.DO.Group(cols...))
+}
+
+func (p projektDo) Having(conds ...gen.Condition) IProjektDo {
+	return p.withDO(p.DO.Having(conds...))
+}
+
+func (p projektDo) Limit(limit int) IProjektDo {
+	return p.withDO(p.DO.Limit(limit))
+}
+
+func (p projektDo) Offset(offset int) IProjektDo {
+	return p.withDO(p.DO.Offset(offset))
+}
+
+func (p projektDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IProjektDo {
+	return p.withDO(p.DO.Scopes(funcs...))
+}
+
+func (p projektDo) Unscoped() IProjektDo {
+	return p.withDO(p.DO.Unscoped())
+}
+
+func (p projektDo) Create(values ...*model.Projekt) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Create(values)
+}
+
+func (p projektDo) CreateInBatches(values []*model.Projekt, batchSize int) error {
+	return p.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 (p projektDo) Save(values ...*model.Projekt) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return p.DO.Save(values)
+}
+
+func (p projektDo) First() (*model.Projekt, error) {
+	if result, err := p.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Projekt), nil
+	}
+}
+
+func (p projektDo) Take() (*model.Projekt, error) {
+	if result, err := p.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Projekt), nil
+	}
+}
+
+func (p projektDo) Last() (*model.Projekt, error) {
+	if result, err := p.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Projekt), nil
+	}
+}
+
+func (p projektDo) Find() ([]*model.Projekt, error) {
+	result, err := p.DO.Find()
+	return result.([]*model.Projekt), err
+}
+
+func (p projektDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Projekt, err error) {
+	buf := make([]*model.Projekt, 0, batchSize)
+	err = p.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 (p projektDo) FindInBatches(result *[]*model.Projekt, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return p.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (p projektDo) Attrs(attrs ...field.AssignExpr) IProjektDo {
+	return p.withDO(p.DO.Attrs(attrs...))
+}
+
+func (p projektDo) Assign(attrs ...field.AssignExpr) IProjektDo {
+	return p.withDO(p.DO.Assign(attrs...))
+}
+
+func (p projektDo) Joins(fields ...field.RelationField) IProjektDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Joins(_f))
+	}
+	return &p
+}
+
+func (p projektDo) Preload(fields ...field.RelationField) IProjektDo {
+	for _, _f := range fields {
+		p = *p.withDO(p.DO.Preload(_f))
+	}
+	return &p
+}
+
+func (p projektDo) FirstOrInit() (*model.Projekt, error) {
+	if result, err := p.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Projekt), nil
+	}
+}
+
+func (p projektDo) FirstOrCreate() (*model.Projekt, error) {
+	if result, err := p.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Projekt), nil
+	}
+}
+
+func (p projektDo) FindByPage(offset int, limit int) (result []*model.Projekt, count int64, err error) {
+	result, err = p.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 = p.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (p projektDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = p.Count()
+	if err != nil {
+		return
+	}
+
+	err = p.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (p projektDo) Scan(result interface{}) (err error) {
+	return p.DO.Scan(result)
+}
+
+func (p projektDo) Delete(models ...*model.Projekt) (result gen.ResultInfo, err error) {
+	return p.DO.Delete(models)
+}
+
+func (p *projektDo) withDO(do gen.Dao) *projektDo {
+	p.DO = *do.(*gen.DO)
+	return p
+}

query/rechnungs.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newRechnung(db *gorm.DB, opts ...gen.DOOption) rechnung {
+	_rechnung := rechnung{}
+
+	_rechnung.rechnungDo.UseDB(db, opts...)
+	_rechnung.rechnungDo.UseModel(&model.Rechnung{})
+
+	tableName := _rechnung.rechnungDo.TableName()
+	_rechnung.ALL = field.NewAsterisk(tableName)
+	_rechnung.ID = field.NewUint(tableName, "id")
+	_rechnung.CreatedAt = field.NewTime(tableName, "created_at")
+	_rechnung.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_rechnung.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_rechnung.fillFieldMap()
+
+	return _rechnung
+}
+
+type rechnung struct {
+	rechnungDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (r rechnung) Table(newTableName string) *rechnung {
+	r.rechnungDo.UseTable(newTableName)
+	return r.updateTableName(newTableName)
+}
+
+func (r rechnung) As(alias string) *rechnung {
+	r.rechnungDo.DO = *(r.rechnungDo.As(alias).(*gen.DO))
+	return r.updateTableName(alias)
+}
+
+func (r *rechnung) updateTableName(table string) *rechnung {
+	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.fillFieldMap()
+
+	return r
+}
+
+func (r *rechnung) 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 *rechnung) fillFieldMap() {
+	r.fieldMap = make(map[string]field.Expr, 4)
+	r.fieldMap["id"] = r.ID
+	r.fieldMap["created_at"] = r.CreatedAt
+	r.fieldMap["updated_at"] = r.UpdatedAt
+	r.fieldMap["deleted_at"] = r.DeletedAt
+}
+
+func (r rechnung) clone(db *gorm.DB) rechnung {
+	r.rechnungDo.ReplaceConnPool(db.Statement.ConnPool)
+	return r
+}
+
+func (r rechnung) replaceDB(db *gorm.DB) rechnung {
+	r.rechnungDo.ReplaceDB(db)
+	return r
+}
+
+type rechnungDo struct{ gen.DO }
+
+type IRechnungDo interface {
+	gen.SubQuery
+	Debug() IRechnungDo
+	WithContext(ctx context.Context) IRechnungDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IRechnungDo
+	WriteDB() IRechnungDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IRechnungDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IRechnungDo
+	Not(conds ...gen.Condition) IRechnungDo
+	Or(conds ...gen.Condition) IRechnungDo
+	Select(conds ...field.Expr) IRechnungDo
+	Where(conds ...gen.Condition) IRechnungDo
+	Order(conds ...field.Expr) IRechnungDo
+	Distinct(cols ...field.Expr) IRechnungDo
+	Omit(cols ...field.Expr) IRechnungDo
+	Join(table schema.Tabler, on ...field.Expr) IRechnungDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo
+	Group(cols ...field.Expr) IRechnungDo
+	Having(conds ...gen.Condition) IRechnungDo
+	Limit(limit int) IRechnungDo
+	Offset(offset int) IRechnungDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo
+	Unscoped() IRechnungDo
+	Create(values ...*model.Rechnung) error
+	CreateInBatches(values []*model.Rechnung, batchSize int) error
+	Save(values ...*model.Rechnung) error
+	First() (*model.Rechnung, error)
+	Take() (*model.Rechnung, error)
+	Last() (*model.Rechnung, error)
+	Find() ([]*model.Rechnung, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error)
+	FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Rechnung) (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) IRechnungDo
+	Assign(attrs ...field.AssignExpr) IRechnungDo
+	Joins(fields ...field.RelationField) IRechnungDo
+	Preload(fields ...field.RelationField) IRechnungDo
+	FirstOrInit() (*model.Rechnung, error)
+	FirstOrCreate() (*model.Rechnung, error)
+	FindByPage(offset int, limit int) (result []*model.Rechnung, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IRechnungDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (r rechnungDo) Debug() IRechnungDo {
+	return r.withDO(r.DO.Debug())
+}
+
+func (r rechnungDo) WithContext(ctx context.Context) IRechnungDo {
+	return r.withDO(r.DO.WithContext(ctx))
+}
+
+func (r rechnungDo) ReadDB() IRechnungDo {
+	return r.Clauses(dbresolver.Read)
+}
+
+func (r rechnungDo) WriteDB() IRechnungDo {
+	return r.Clauses(dbresolver.Write)
+}
+
+func (r rechnungDo) Session(config *gorm.Session) IRechnungDo {
+	return r.withDO(r.DO.Session(config))
+}
+
+func (r rechnungDo) Clauses(conds ...clause.Expression) IRechnungDo {
+	return r.withDO(r.DO.Clauses(conds...))
+}
+
+func (r rechnungDo) Returning(value interface{}, columns ...string) IRechnungDo {
+	return r.withDO(r.DO.Returning(value, columns...))
+}
+
+func (r rechnungDo) Not(conds ...gen.Condition) IRechnungDo {
+	return r.withDO(r.DO.Not(conds...))
+}
+
+func (r rechnungDo) Or(conds ...gen.Condition) IRechnungDo {
+	return r.withDO(r.DO.Or(conds...))
+}
+
+func (r rechnungDo) Select(conds ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.Select(conds...))
+}
+
+func (r rechnungDo) Where(conds ...gen.Condition) IRechnungDo {
+	return r.withDO(r.DO.Where(conds...))
+}
+
+func (r rechnungDo) Order(conds ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.Order(conds...))
+}
+
+func (r rechnungDo) Distinct(cols ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.Distinct(cols...))
+}
+
+func (r rechnungDo) Omit(cols ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.Omit(cols...))
+}
+
+func (r rechnungDo) Join(table schema.Tabler, on ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.Join(table, on...))
+}
+
+func (r rechnungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.LeftJoin(table, on...))
+}
+
+func (r rechnungDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.RightJoin(table, on...))
+}
+
+func (r rechnungDo) Group(cols ...field.Expr) IRechnungDo {
+	return r.withDO(r.DO.Group(cols...))
+}
+
+func (r rechnungDo) Having(conds ...gen.Condition) IRechnungDo {
+	return r.withDO(r.DO.Having(conds...))
+}
+
+func (r rechnungDo) Limit(limit int) IRechnungDo {
+	return r.withDO(r.DO.Limit(limit))
+}
+
+func (r rechnungDo) Offset(offset int) IRechnungDo {
+	return r.withDO(r.DO.Offset(offset))
+}
+
+func (r rechnungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungDo {
+	return r.withDO(r.DO.Scopes(funcs...))
+}
+
+func (r rechnungDo) Unscoped() IRechnungDo {
+	return r.withDO(r.DO.Unscoped())
+}
+
+func (r rechnungDo) Create(values ...*model.Rechnung) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return r.DO.Create(values)
+}
+
+func (r rechnungDo) CreateInBatches(values []*model.Rechnung, 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 rechnungDo) Save(values ...*model.Rechnung) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return r.DO.Save(values)
+}
+
+func (r rechnungDo) First() (*model.Rechnung, error) {
+	if result, err := r.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnung), nil
+	}
+}
+
+func (r rechnungDo) Take() (*model.Rechnung, error) {
+	if result, err := r.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnung), nil
+	}
+}
+
+func (r rechnungDo) Last() (*model.Rechnung, error) {
+	if result, err := r.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnung), nil
+	}
+}
+
+func (r rechnungDo) Find() ([]*model.Rechnung, error) {
+	result, err := r.DO.Find()
+	return result.([]*model.Rechnung), err
+}
+
+func (r rechnungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnung, err error) {
+	buf := make([]*model.Rechnung, 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 rechnungDo) FindInBatches(result *[]*model.Rechnung, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return r.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (r rechnungDo) Attrs(attrs ...field.AssignExpr) IRechnungDo {
+	return r.withDO(r.DO.Attrs(attrs...))
+}
+
+func (r rechnungDo) Assign(attrs ...field.AssignExpr) IRechnungDo {
+	return r.withDO(r.DO.Assign(attrs...))
+}
+
+func (r rechnungDo) Joins(fields ...field.RelationField) IRechnungDo {
+	for _, _f := range fields {
+		r = *r.withDO(r.DO.Joins(_f))
+	}
+	return &r
+}
+
+func (r rechnungDo) Preload(fields ...field.RelationField) IRechnungDo {
+	for _, _f := range fields {
+		r = *r.withDO(r.DO.Preload(_f))
+	}
+	return &r
+}
+
+func (r rechnungDo) FirstOrInit() (*model.Rechnung, error) {
+	if result, err := r.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnung), nil
+	}
+}
+
+func (r rechnungDo) FirstOrCreate() (*model.Rechnung, error) {
+	if result, err := r.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnung), nil
+	}
+}
+
+func (r rechnungDo) FindByPage(offset int, limit int) (result []*model.Rechnung, 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 rechnungDo) 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 rechnungDo) Scan(result interface{}) (err error) {
+	return r.DO.Scan(result)
+}
+
+func (r rechnungDo) Delete(models ...*model.Rechnung) (result gen.ResultInfo, err error) {
+	return r.DO.Delete(models)
+}
+
+func (r *rechnungDo) withDO(do gen.Dao) *rechnungDo {
+	r.DO = *do.(*gen.DO)
+	return r
+}

query/rechnungspositions.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newRechnungsposition(db *gorm.DB, opts ...gen.DOOption) rechnungsposition {
+	_rechnungsposition := rechnungsposition{}
+
+	_rechnungsposition.rechnungspositionDo.UseDB(db, opts...)
+	_rechnungsposition.rechnungspositionDo.UseModel(&model.Rechnungsposition{})
+
+	tableName := _rechnungsposition.rechnungspositionDo.TableName()
+	_rechnungsposition.ALL = field.NewAsterisk(tableName)
+	_rechnungsposition.ID = field.NewUint(tableName, "id")
+	_rechnungsposition.CreatedAt = field.NewTime(tableName, "created_at")
+	_rechnungsposition.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_rechnungsposition.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_rechnungsposition.fillFieldMap()
+
+	return _rechnungsposition
+}
+
+type rechnungsposition struct {
+	rechnungspositionDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (r rechnungsposition) Table(newTableName string) *rechnungsposition {
+	r.rechnungspositionDo.UseTable(newTableName)
+	return r.updateTableName(newTableName)
+}
+
+func (r rechnungsposition) As(alias string) *rechnungsposition {
+	r.rechnungspositionDo.DO = *(r.rechnungspositionDo.As(alias).(*gen.DO))
+	return r.updateTableName(alias)
+}
+
+func (r *rechnungsposition) updateTableName(table string) *rechnungsposition {
+	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.fillFieldMap()
+
+	return r
+}
+
+func (r *rechnungsposition) 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 *rechnungsposition) fillFieldMap() {
+	r.fieldMap = make(map[string]field.Expr, 4)
+	r.fieldMap["id"] = r.ID
+	r.fieldMap["created_at"] = r.CreatedAt
+	r.fieldMap["updated_at"] = r.UpdatedAt
+	r.fieldMap["deleted_at"] = r.DeletedAt
+}
+
+func (r rechnungsposition) clone(db *gorm.DB) rechnungsposition {
+	r.rechnungspositionDo.ReplaceConnPool(db.Statement.ConnPool)
+	return r
+}
+
+func (r rechnungsposition) replaceDB(db *gorm.DB) rechnungsposition {
+	r.rechnungspositionDo.ReplaceDB(db)
+	return r
+}
+
+type rechnungspositionDo struct{ gen.DO }
+
+type IRechnungspositionDo interface {
+	gen.SubQuery
+	Debug() IRechnungspositionDo
+	WithContext(ctx context.Context) IRechnungspositionDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IRechnungspositionDo
+	WriteDB() IRechnungspositionDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IRechnungspositionDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IRechnungspositionDo
+	Not(conds ...gen.Condition) IRechnungspositionDo
+	Or(conds ...gen.Condition) IRechnungspositionDo
+	Select(conds ...field.Expr) IRechnungspositionDo
+	Where(conds ...gen.Condition) IRechnungspositionDo
+	Order(conds ...field.Expr) IRechnungspositionDo
+	Distinct(cols ...field.Expr) IRechnungspositionDo
+	Omit(cols ...field.Expr) IRechnungspositionDo
+	Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo
+	Group(cols ...field.Expr) IRechnungspositionDo
+	Having(conds ...gen.Condition) IRechnungspositionDo
+	Limit(limit int) IRechnungspositionDo
+	Offset(offset int) IRechnungspositionDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo
+	Unscoped() IRechnungspositionDo
+	Create(values ...*model.Rechnungsposition) error
+	CreateInBatches(values []*model.Rechnungsposition, batchSize int) error
+	Save(values ...*model.Rechnungsposition) error
+	First() (*model.Rechnungsposition, error)
+	Take() (*model.Rechnungsposition, error)
+	Last() (*model.Rechnungsposition, error)
+	Find() ([]*model.Rechnungsposition, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error)
+	FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Rechnungsposition) (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) IRechnungspositionDo
+	Assign(attrs ...field.AssignExpr) IRechnungspositionDo
+	Joins(fields ...field.RelationField) IRechnungspositionDo
+	Preload(fields ...field.RelationField) IRechnungspositionDo
+	FirstOrInit() (*model.Rechnungsposition, error)
+	FirstOrCreate() (*model.Rechnungsposition, error)
+	FindByPage(offset int, limit int) (result []*model.Rechnungsposition, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IRechnungspositionDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (r rechnungspositionDo) Debug() IRechnungspositionDo {
+	return r.withDO(r.DO.Debug())
+}
+
+func (r rechnungspositionDo) WithContext(ctx context.Context) IRechnungspositionDo {
+	return r.withDO(r.DO.WithContext(ctx))
+}
+
+func (r rechnungspositionDo) ReadDB() IRechnungspositionDo {
+	return r.Clauses(dbresolver.Read)
+}
+
+func (r rechnungspositionDo) WriteDB() IRechnungspositionDo {
+	return r.Clauses(dbresolver.Write)
+}
+
+func (r rechnungspositionDo) Session(config *gorm.Session) IRechnungspositionDo {
+	return r.withDO(r.DO.Session(config))
+}
+
+func (r rechnungspositionDo) Clauses(conds ...clause.Expression) IRechnungspositionDo {
+	return r.withDO(r.DO.Clauses(conds...))
+}
+
+func (r rechnungspositionDo) Returning(value interface{}, columns ...string) IRechnungspositionDo {
+	return r.withDO(r.DO.Returning(value, columns...))
+}
+
+func (r rechnungspositionDo) Not(conds ...gen.Condition) IRechnungspositionDo {
+	return r.withDO(r.DO.Not(conds...))
+}
+
+func (r rechnungspositionDo) Or(conds ...gen.Condition) IRechnungspositionDo {
+	return r.withDO(r.DO.Or(conds...))
+}
+
+func (r rechnungspositionDo) Select(conds ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.Select(conds...))
+}
+
+func (r rechnungspositionDo) Where(conds ...gen.Condition) IRechnungspositionDo {
+	return r.withDO(r.DO.Where(conds...))
+}
+
+func (r rechnungspositionDo) Order(conds ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.Order(conds...))
+}
+
+func (r rechnungspositionDo) Distinct(cols ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.Distinct(cols...))
+}
+
+func (r rechnungspositionDo) Omit(cols ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.Omit(cols...))
+}
+
+func (r rechnungspositionDo) Join(table schema.Tabler, on ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.Join(table, on...))
+}
+
+func (r rechnungspositionDo) LeftJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.LeftJoin(table, on...))
+}
+
+func (r rechnungspositionDo) RightJoin(table schema.Tabler, on ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.RightJoin(table, on...))
+}
+
+func (r rechnungspositionDo) Group(cols ...field.Expr) IRechnungspositionDo {
+	return r.withDO(r.DO.Group(cols...))
+}
+
+func (r rechnungspositionDo) Having(conds ...gen.Condition) IRechnungspositionDo {
+	return r.withDO(r.DO.Having(conds...))
+}
+
+func (r rechnungspositionDo) Limit(limit int) IRechnungspositionDo {
+	return r.withDO(r.DO.Limit(limit))
+}
+
+func (r rechnungspositionDo) Offset(offset int) IRechnungspositionDo {
+	return r.withDO(r.DO.Offset(offset))
+}
+
+func (r rechnungspositionDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IRechnungspositionDo {
+	return r.withDO(r.DO.Scopes(funcs...))
+}
+
+func (r rechnungspositionDo) Unscoped() IRechnungspositionDo {
+	return r.withDO(r.DO.Unscoped())
+}
+
+func (r rechnungspositionDo) Create(values ...*model.Rechnungsposition) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return r.DO.Create(values)
+}
+
+func (r rechnungspositionDo) CreateInBatches(values []*model.Rechnungsposition, 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 rechnungspositionDo) Save(values ...*model.Rechnungsposition) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return r.DO.Save(values)
+}
+
+func (r rechnungspositionDo) First() (*model.Rechnungsposition, error) {
+	if result, err := r.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnungsposition), nil
+	}
+}
+
+func (r rechnungspositionDo) Take() (*model.Rechnungsposition, error) {
+	if result, err := r.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnungsposition), nil
+	}
+}
+
+func (r rechnungspositionDo) Last() (*model.Rechnungsposition, error) {
+	if result, err := r.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnungsposition), nil
+	}
+}
+
+func (r rechnungspositionDo) Find() ([]*model.Rechnungsposition, error) {
+	result, err := r.DO.Find()
+	return result.([]*model.Rechnungsposition), err
+}
+
+func (r rechnungspositionDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Rechnungsposition, err error) {
+	buf := make([]*model.Rechnungsposition, 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 rechnungspositionDo) FindInBatches(result *[]*model.Rechnungsposition, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return r.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (r rechnungspositionDo) Attrs(attrs ...field.AssignExpr) IRechnungspositionDo {
+	return r.withDO(r.DO.Attrs(attrs...))
+}
+
+func (r rechnungspositionDo) Assign(attrs ...field.AssignExpr) IRechnungspositionDo {
+	return r.withDO(r.DO.Assign(attrs...))
+}
+
+func (r rechnungspositionDo) Joins(fields ...field.RelationField) IRechnungspositionDo {
+	for _, _f := range fields {
+		r = *r.withDO(r.DO.Joins(_f))
+	}
+	return &r
+}
+
+func (r rechnungspositionDo) Preload(fields ...field.RelationField) IRechnungspositionDo {
+	for _, _f := range fields {
+		r = *r.withDO(r.DO.Preload(_f))
+	}
+	return &r
+}
+
+func (r rechnungspositionDo) FirstOrInit() (*model.Rechnungsposition, error) {
+	if result, err := r.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnungsposition), nil
+	}
+}
+
+func (r rechnungspositionDo) FirstOrCreate() (*model.Rechnungsposition, error) {
+	if result, err := r.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Rechnungsposition), nil
+	}
+}
+
+func (r rechnungspositionDo) FindByPage(offset int, limit int) (result []*model.Rechnungsposition, 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 rechnungspositionDo) 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 rechnungspositionDo) Scan(result interface{}) (err error) {
+	return r.DO.Scan(result)
+}
+
+func (r rechnungspositionDo) Delete(models ...*model.Rechnungsposition) (result gen.ResultInfo, err error) {
+	return r.DO.Delete(models)
+}
+
+func (r *rechnungspositionDo) withDO(do gen.Dao) *rechnungspositionDo {
+	r.DO = *do.(*gen.DO)
+	return r
+}

query/scanobjects.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newScanobject(db *gorm.DB, opts ...gen.DOOption) scanobject {
+	_scanobject := scanobject{}
+
+	_scanobject.scanobjectDo.UseDB(db, opts...)
+	_scanobject.scanobjectDo.UseModel(&model.Scanobject{})
+
+	tableName := _scanobject.scanobjectDo.TableName()
+	_scanobject.ALL = field.NewAsterisk(tableName)
+	_scanobject.ID = field.NewUint(tableName, "id")
+	_scanobject.CreatedAt = field.NewTime(tableName, "created_at")
+	_scanobject.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_scanobject.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_scanobject.fillFieldMap()
+
+	return _scanobject
+}
+
+type scanobject struct {
+	scanobjectDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (s scanobject) Table(newTableName string) *scanobject {
+	s.scanobjectDo.UseTable(newTableName)
+	return s.updateTableName(newTableName)
+}
+
+func (s scanobject) As(alias string) *scanobject {
+	s.scanobjectDo.DO = *(s.scanobjectDo.As(alias).(*gen.DO))
+	return s.updateTableName(alias)
+}
+
+func (s *scanobject) updateTableName(table string) *scanobject {
+	s.ALL = field.NewAsterisk(table)
+	s.ID = field.NewUint(table, "id")
+	s.CreatedAt = field.NewTime(table, "created_at")
+	s.UpdatedAt = field.NewTime(table, "updated_at")
+	s.DeletedAt = field.NewField(table, "deleted_at")
+
+	s.fillFieldMap()
+
+	return s
+}
+
+func (s *scanobject) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := s.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (s *scanobject) fillFieldMap() {
+	s.fieldMap = make(map[string]field.Expr, 4)
+	s.fieldMap["id"] = s.ID
+	s.fieldMap["created_at"] = s.CreatedAt
+	s.fieldMap["updated_at"] = s.UpdatedAt
+	s.fieldMap["deleted_at"] = s.DeletedAt
+}
+
+func (s scanobject) clone(db *gorm.DB) scanobject {
+	s.scanobjectDo.ReplaceConnPool(db.Statement.ConnPool)
+	return s
+}
+
+func (s scanobject) replaceDB(db *gorm.DB) scanobject {
+	s.scanobjectDo.ReplaceDB(db)
+	return s
+}
+
+type scanobjectDo struct{ gen.DO }
+
+type IScanobjectDo interface {
+	gen.SubQuery
+	Debug() IScanobjectDo
+	WithContext(ctx context.Context) IScanobjectDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IScanobjectDo
+	WriteDB() IScanobjectDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IScanobjectDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IScanobjectDo
+	Not(conds ...gen.Condition) IScanobjectDo
+	Or(conds ...gen.Condition) IScanobjectDo
+	Select(conds ...field.Expr) IScanobjectDo
+	Where(conds ...gen.Condition) IScanobjectDo
+	Order(conds ...field.Expr) IScanobjectDo
+	Distinct(cols ...field.Expr) IScanobjectDo
+	Omit(cols ...field.Expr) IScanobjectDo
+	Join(table schema.Tabler, on ...field.Expr) IScanobjectDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo
+	Group(cols ...field.Expr) IScanobjectDo
+	Having(conds ...gen.Condition) IScanobjectDo
+	Limit(limit int) IScanobjectDo
+	Offset(offset int) IScanobjectDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo
+	Unscoped() IScanobjectDo
+	Create(values ...*model.Scanobject) error
+	CreateInBatches(values []*model.Scanobject, batchSize int) error
+	Save(values ...*model.Scanobject) error
+	First() (*model.Scanobject, error)
+	Take() (*model.Scanobject, error)
+	Last() (*model.Scanobject, error)
+	Find() ([]*model.Scanobject, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error)
+	FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Scanobject) (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) IScanobjectDo
+	Assign(attrs ...field.AssignExpr) IScanobjectDo
+	Joins(fields ...field.RelationField) IScanobjectDo
+	Preload(fields ...field.RelationField) IScanobjectDo
+	FirstOrInit() (*model.Scanobject, error)
+	FirstOrCreate() (*model.Scanobject, error)
+	FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IScanobjectDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (s scanobjectDo) Debug() IScanobjectDo {
+	return s.withDO(s.DO.Debug())
+}
+
+func (s scanobjectDo) WithContext(ctx context.Context) IScanobjectDo {
+	return s.withDO(s.DO.WithContext(ctx))
+}
+
+func (s scanobjectDo) ReadDB() IScanobjectDo {
+	return s.Clauses(dbresolver.Read)
+}
+
+func (s scanobjectDo) WriteDB() IScanobjectDo {
+	return s.Clauses(dbresolver.Write)
+}
+
+func (s scanobjectDo) Session(config *gorm.Session) IScanobjectDo {
+	return s.withDO(s.DO.Session(config))
+}
+
+func (s scanobjectDo) Clauses(conds ...clause.Expression) IScanobjectDo {
+	return s.withDO(s.DO.Clauses(conds...))
+}
+
+func (s scanobjectDo) Returning(value interface{}, columns ...string) IScanobjectDo {
+	return s.withDO(s.DO.Returning(value, columns...))
+}
+
+func (s scanobjectDo) Not(conds ...gen.Condition) IScanobjectDo {
+	return s.withDO(s.DO.Not(conds...))
+}
+
+func (s scanobjectDo) Or(conds ...gen.Condition) IScanobjectDo {
+	return s.withDO(s.DO.Or(conds...))
+}
+
+func (s scanobjectDo) Select(conds ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.Select(conds...))
+}
+
+func (s scanobjectDo) Where(conds ...gen.Condition) IScanobjectDo {
+	return s.withDO(s.DO.Where(conds...))
+}
+
+func (s scanobjectDo) Order(conds ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.Order(conds...))
+}
+
+func (s scanobjectDo) Distinct(cols ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.Distinct(cols...))
+}
+
+func (s scanobjectDo) Omit(cols ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.Omit(cols...))
+}
+
+func (s scanobjectDo) Join(table schema.Tabler, on ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.Join(table, on...))
+}
+
+func (s scanobjectDo) LeftJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.LeftJoin(table, on...))
+}
+
+func (s scanobjectDo) RightJoin(table schema.Tabler, on ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.RightJoin(table, on...))
+}
+
+func (s scanobjectDo) Group(cols ...field.Expr) IScanobjectDo {
+	return s.withDO(s.DO.Group(cols...))
+}
+
+func (s scanobjectDo) Having(conds ...gen.Condition) IScanobjectDo {
+	return s.withDO(s.DO.Having(conds...))
+}
+
+func (s scanobjectDo) Limit(limit int) IScanobjectDo {
+	return s.withDO(s.DO.Limit(limit))
+}
+
+func (s scanobjectDo) Offset(offset int) IScanobjectDo {
+	return s.withDO(s.DO.Offset(offset))
+}
+
+func (s scanobjectDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IScanobjectDo {
+	return s.withDO(s.DO.Scopes(funcs...))
+}
+
+func (s scanobjectDo) Unscoped() IScanobjectDo {
+	return s.withDO(s.DO.Unscoped())
+}
+
+func (s scanobjectDo) Create(values ...*model.Scanobject) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return s.DO.Create(values)
+}
+
+func (s scanobjectDo) CreateInBatches(values []*model.Scanobject, batchSize int) error {
+	return s.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 (s scanobjectDo) Save(values ...*model.Scanobject) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return s.DO.Save(values)
+}
+
+func (s scanobjectDo) First() (*model.Scanobject, error) {
+	if result, err := s.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Scanobject), nil
+	}
+}
+
+func (s scanobjectDo) Take() (*model.Scanobject, error) {
+	if result, err := s.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Scanobject), nil
+	}
+}
+
+func (s scanobjectDo) Last() (*model.Scanobject, error) {
+	if result, err := s.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Scanobject), nil
+	}
+}
+
+func (s scanobjectDo) Find() ([]*model.Scanobject, error) {
+	result, err := s.DO.Find()
+	return result.([]*model.Scanobject), err
+}
+
+func (s scanobjectDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Scanobject, err error) {
+	buf := make([]*model.Scanobject, 0, batchSize)
+	err = s.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 (s scanobjectDo) FindInBatches(result *[]*model.Scanobject, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return s.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (s scanobjectDo) Attrs(attrs ...field.AssignExpr) IScanobjectDo {
+	return s.withDO(s.DO.Attrs(attrs...))
+}
+
+func (s scanobjectDo) Assign(attrs ...field.AssignExpr) IScanobjectDo {
+	return s.withDO(s.DO.Assign(attrs...))
+}
+
+func (s scanobjectDo) Joins(fields ...field.RelationField) IScanobjectDo {
+	for _, _f := range fields {
+		s = *s.withDO(s.DO.Joins(_f))
+	}
+	return &s
+}
+
+func (s scanobjectDo) Preload(fields ...field.RelationField) IScanobjectDo {
+	for _, _f := range fields {
+		s = *s.withDO(s.DO.Preload(_f))
+	}
+	return &s
+}
+
+func (s scanobjectDo) FirstOrInit() (*model.Scanobject, error) {
+	if result, err := s.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Scanobject), nil
+	}
+}
+
+func (s scanobjectDo) FirstOrCreate() (*model.Scanobject, error) {
+	if result, err := s.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Scanobject), nil
+	}
+}
+
+func (s scanobjectDo) FindByPage(offset int, limit int) (result []*model.Scanobject, count int64, err error) {
+	result, err = s.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 = s.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (s scanobjectDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = s.Count()
+	if err != nil {
+		return
+	}
+
+	err = s.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (s scanobjectDo) Scan(result interface{}) (err error) {
+	return s.DO.Scan(result)
+}
+
+func (s scanobjectDo) Delete(models ...*model.Scanobject) (result gen.ResultInfo, err error) {
+	return s.DO.Delete(models)
+}
+
+func (s *scanobjectDo) withDO(do gen.Dao) *scanobjectDo {
+	s.DO = *do.(*gen.DO)
+	return s
+}

query/users.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newUser(db *gorm.DB, opts ...gen.DOOption) user {
+	_user := user{}
+
+	_user.userDo.UseDB(db, opts...)
+	_user.userDo.UseModel(&model.User{})
+
+	tableName := _user.userDo.TableName()
+	_user.ALL = field.NewAsterisk(tableName)
+	_user.ID = field.NewUint(tableName, "id")
+	_user.CreatedAt = field.NewTime(tableName, "created_at")
+	_user.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_user.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_user.fillFieldMap()
+
+	return _user
+}
+
+type user struct {
+	userDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (u user) Table(newTableName string) *user {
+	u.userDo.UseTable(newTableName)
+	return u.updateTableName(newTableName)
+}
+
+func (u user) As(alias string) *user {
+	u.userDo.DO = *(u.userDo.As(alias).(*gen.DO))
+	return u.updateTableName(alias)
+}
+
+func (u *user) updateTableName(table string) *user {
+	u.ALL = field.NewAsterisk(table)
+	u.ID = field.NewUint(table, "id")
+	u.CreatedAt = field.NewTime(table, "created_at")
+	u.UpdatedAt = field.NewTime(table, "updated_at")
+	u.DeletedAt = field.NewField(table, "deleted_at")
+
+	u.fillFieldMap()
+
+	return u
+}
+
+func (u *user) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := u.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (u *user) fillFieldMap() {
+	u.fieldMap = make(map[string]field.Expr, 4)
+	u.fieldMap["id"] = u.ID
+	u.fieldMap["created_at"] = u.CreatedAt
+	u.fieldMap["updated_at"] = u.UpdatedAt
+	u.fieldMap["deleted_at"] = u.DeletedAt
+}
+
+func (u user) clone(db *gorm.DB) user {
+	u.userDo.ReplaceConnPool(db.Statement.ConnPool)
+	return u
+}
+
+func (u user) replaceDB(db *gorm.DB) user {
+	u.userDo.ReplaceDB(db)
+	return u
+}
+
+type userDo struct{ gen.DO }
+
+type IUserDo interface {
+	gen.SubQuery
+	Debug() IUserDo
+	WithContext(ctx context.Context) IUserDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IUserDo
+	WriteDB() IUserDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IUserDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IUserDo
+	Not(conds ...gen.Condition) IUserDo
+	Or(conds ...gen.Condition) IUserDo
+	Select(conds ...field.Expr) IUserDo
+	Where(conds ...gen.Condition) IUserDo
+	Order(conds ...field.Expr) IUserDo
+	Distinct(cols ...field.Expr) IUserDo
+	Omit(cols ...field.Expr) IUserDo
+	Join(table schema.Tabler, on ...field.Expr) IUserDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IUserDo
+	Group(cols ...field.Expr) IUserDo
+	Having(conds ...gen.Condition) IUserDo
+	Limit(limit int) IUserDo
+	Offset(offset int) IUserDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo
+	Unscoped() IUserDo
+	Create(values ...*model.User) error
+	CreateInBatches(values []*model.User, batchSize int) error
+	Save(values ...*model.User) error
+	First() (*model.User, error)
+	Take() (*model.User, error)
+	Last() (*model.User, error)
+	Find() ([]*model.User, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error)
+	FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.User) (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) IUserDo
+	Assign(attrs ...field.AssignExpr) IUserDo
+	Joins(fields ...field.RelationField) IUserDo
+	Preload(fields ...field.RelationField) IUserDo
+	FirstOrInit() (*model.User, error)
+	FirstOrCreate() (*model.User, error)
+	FindByPage(offset int, limit int) (result []*model.User, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IUserDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (u userDo) Debug() IUserDo {
+	return u.withDO(u.DO.Debug())
+}
+
+func (u userDo) WithContext(ctx context.Context) IUserDo {
+	return u.withDO(u.DO.WithContext(ctx))
+}
+
+func (u userDo) ReadDB() IUserDo {
+	return u.Clauses(dbresolver.Read)
+}
+
+func (u userDo) WriteDB() IUserDo {
+	return u.Clauses(dbresolver.Write)
+}
+
+func (u userDo) Session(config *gorm.Session) IUserDo {
+	return u.withDO(u.DO.Session(config))
+}
+
+func (u userDo) Clauses(conds ...clause.Expression) IUserDo {
+	return u.withDO(u.DO.Clauses(conds...))
+}
+
+func (u userDo) Returning(value interface{}, columns ...string) IUserDo {
+	return u.withDO(u.DO.Returning(value, columns...))
+}
+
+func (u userDo) Not(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Not(conds...))
+}
+
+func (u userDo) Or(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Or(conds...))
+}
+
+func (u userDo) Select(conds ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Select(conds...))
+}
+
+func (u userDo) Where(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Where(conds...))
+}
+
+func (u userDo) Order(conds ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Order(conds...))
+}
+
+func (u userDo) Distinct(cols ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Distinct(cols...))
+}
+
+func (u userDo) Omit(cols ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Omit(cols...))
+}
+
+func (u userDo) Join(table schema.Tabler, on ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Join(table, on...))
+}
+
+func (u userDo) LeftJoin(table schema.Tabler, on ...field.Expr) IUserDo {
+	return u.withDO(u.DO.LeftJoin(table, on...))
+}
+
+func (u userDo) RightJoin(table schema.Tabler, on ...field.Expr) IUserDo {
+	return u.withDO(u.DO.RightJoin(table, on...))
+}
+
+func (u userDo) Group(cols ...field.Expr) IUserDo {
+	return u.withDO(u.DO.Group(cols...))
+}
+
+func (u userDo) Having(conds ...gen.Condition) IUserDo {
+	return u.withDO(u.DO.Having(conds...))
+}
+
+func (u userDo) Limit(limit int) IUserDo {
+	return u.withDO(u.DO.Limit(limit))
+}
+
+func (u userDo) Offset(offset int) IUserDo {
+	return u.withDO(u.DO.Offset(offset))
+}
+
+func (u userDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IUserDo {
+	return u.withDO(u.DO.Scopes(funcs...))
+}
+
+func (u userDo) Unscoped() IUserDo {
+	return u.withDO(u.DO.Unscoped())
+}
+
+func (u userDo) Create(values ...*model.User) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Create(values)
+}
+
+func (u userDo) CreateInBatches(values []*model.User, batchSize int) error {
+	return u.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 (u userDo) Save(values ...*model.User) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return u.DO.Save(values)
+}
+
+func (u userDo) First() (*model.User, error) {
+	if result, err := u.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.User), nil
+	}
+}
+
+func (u userDo) Take() (*model.User, error) {
+	if result, err := u.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.User), nil
+	}
+}
+
+func (u userDo) Last() (*model.User, error) {
+	if result, err := u.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.User), nil
+	}
+}
+
+func (u userDo) Find() ([]*model.User, error) {
+	result, err := u.DO.Find()
+	return result.([]*model.User), err
+}
+
+func (u userDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.User, err error) {
+	buf := make([]*model.User, 0, batchSize)
+	err = u.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 (u userDo) FindInBatches(result *[]*model.User, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return u.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (u userDo) Attrs(attrs ...field.AssignExpr) IUserDo {
+	return u.withDO(u.DO.Attrs(attrs...))
+}
+
+func (u userDo) Assign(attrs ...field.AssignExpr) IUserDo {
+	return u.withDO(u.DO.Assign(attrs...))
+}
+
+func (u userDo) Joins(fields ...field.RelationField) IUserDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Joins(_f))
+	}
+	return &u
+}
+
+func (u userDo) Preload(fields ...field.RelationField) IUserDo {
+	for _, _f := range fields {
+		u = *u.withDO(u.DO.Preload(_f))
+	}
+	return &u
+}
+
+func (u userDo) FirstOrInit() (*model.User, error) {
+	if result, err := u.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.User), nil
+	}
+}
+
+func (u userDo) FirstOrCreate() (*model.User, error) {
+	if result, err := u.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.User), nil
+	}
+}
+
+func (u userDo) FindByPage(offset int, limit int) (result []*model.User, count int64, err error) {
+	result, err = u.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 = u.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (u userDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = u.Count()
+	if err != nil {
+		return
+	}
+
+	err = u.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (u userDo) Scan(result interface{}) (err error) {
+	return u.DO.Scan(result)
+}
+
+func (u userDo) Delete(models ...*model.User) (result gen.ResultInfo, err error) {
+	return u.DO.Delete(models)
+}
+
+func (u *userDo) withDO(do gen.Dao) *userDo {
+	u.DO = *do.(*gen.DO)
+	return u
+}

query/zahlungs.gen.go

@@ -0,0 +1,395 @@
+// 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"
+	"database/sql"
+
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+	"gorm.io/gorm/schema"
+
+	"gorm.io/gen"
+	"gorm.io/gen/field"
+
+	"gorm.io/plugin/dbresolver"
+
+	"git.kocoder.xyz/kocoded/vt/model"
+)
+
+func newZahlung(db *gorm.DB, opts ...gen.DOOption) zahlung {
+	_zahlung := zahlung{}
+
+	_zahlung.zahlungDo.UseDB(db, opts...)
+	_zahlung.zahlungDo.UseModel(&model.Zahlung{})
+
+	tableName := _zahlung.zahlungDo.TableName()
+	_zahlung.ALL = field.NewAsterisk(tableName)
+	_zahlung.ID = field.NewUint(tableName, "id")
+	_zahlung.CreatedAt = field.NewTime(tableName, "created_at")
+	_zahlung.UpdatedAt = field.NewTime(tableName, "updated_at")
+	_zahlung.DeletedAt = field.NewField(tableName, "deleted_at")
+
+	_zahlung.fillFieldMap()
+
+	return _zahlung
+}
+
+type zahlung struct {
+	zahlungDo
+
+	ALL       field.Asterisk
+	ID        field.Uint
+	CreatedAt field.Time
+	UpdatedAt field.Time
+	DeletedAt field.Field
+
+	fieldMap map[string]field.Expr
+}
+
+func (z zahlung) Table(newTableName string) *zahlung {
+	z.zahlungDo.UseTable(newTableName)
+	return z.updateTableName(newTableName)
+}
+
+func (z zahlung) As(alias string) *zahlung {
+	z.zahlungDo.DO = *(z.zahlungDo.As(alias).(*gen.DO))
+	return z.updateTableName(alias)
+}
+
+func (z *zahlung) updateTableName(table string) *zahlung {
+	z.ALL = field.NewAsterisk(table)
+	z.ID = field.NewUint(table, "id")
+	z.CreatedAt = field.NewTime(table, "created_at")
+	z.UpdatedAt = field.NewTime(table, "updated_at")
+	z.DeletedAt = field.NewField(table, "deleted_at")
+
+	z.fillFieldMap()
+
+	return z
+}
+
+func (z *zahlung) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
+	_f, ok := z.fieldMap[fieldName]
+	if !ok || _f == nil {
+		return nil, false
+	}
+	_oe, ok := _f.(field.OrderExpr)
+	return _oe, ok
+}
+
+func (z *zahlung) fillFieldMap() {
+	z.fieldMap = make(map[string]field.Expr, 4)
+	z.fieldMap["id"] = z.ID
+	z.fieldMap["created_at"] = z.CreatedAt
+	z.fieldMap["updated_at"] = z.UpdatedAt
+	z.fieldMap["deleted_at"] = z.DeletedAt
+}
+
+func (z zahlung) clone(db *gorm.DB) zahlung {
+	z.zahlungDo.ReplaceConnPool(db.Statement.ConnPool)
+	return z
+}
+
+func (z zahlung) replaceDB(db *gorm.DB) zahlung {
+	z.zahlungDo.ReplaceDB(db)
+	return z
+}
+
+type zahlungDo struct{ gen.DO }
+
+type IZahlungDo interface {
+	gen.SubQuery
+	Debug() IZahlungDo
+	WithContext(ctx context.Context) IZahlungDo
+	WithResult(fc func(tx gen.Dao)) gen.ResultInfo
+	ReplaceDB(db *gorm.DB)
+	ReadDB() IZahlungDo
+	WriteDB() IZahlungDo
+	As(alias string) gen.Dao
+	Session(config *gorm.Session) IZahlungDo
+	Columns(cols ...field.Expr) gen.Columns
+	Clauses(conds ...clause.Expression) IZahlungDo
+	Not(conds ...gen.Condition) IZahlungDo
+	Or(conds ...gen.Condition) IZahlungDo
+	Select(conds ...field.Expr) IZahlungDo
+	Where(conds ...gen.Condition) IZahlungDo
+	Order(conds ...field.Expr) IZahlungDo
+	Distinct(cols ...field.Expr) IZahlungDo
+	Omit(cols ...field.Expr) IZahlungDo
+	Join(table schema.Tabler, on ...field.Expr) IZahlungDo
+	LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo
+	RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo
+	Group(cols ...field.Expr) IZahlungDo
+	Having(conds ...gen.Condition) IZahlungDo
+	Limit(limit int) IZahlungDo
+	Offset(offset int) IZahlungDo
+	Count() (count int64, err error)
+	Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo
+	Unscoped() IZahlungDo
+	Create(values ...*model.Zahlung) error
+	CreateInBatches(values []*model.Zahlung, batchSize int) error
+	Save(values ...*model.Zahlung) error
+	First() (*model.Zahlung, error)
+	Take() (*model.Zahlung, error)
+	Last() (*model.Zahlung, error)
+	Find() ([]*model.Zahlung, error)
+	FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error)
+	FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error
+	Pluck(column field.Expr, dest interface{}) error
+	Delete(...*model.Zahlung) (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) IZahlungDo
+	Assign(attrs ...field.AssignExpr) IZahlungDo
+	Joins(fields ...field.RelationField) IZahlungDo
+	Preload(fields ...field.RelationField) IZahlungDo
+	FirstOrInit() (*model.Zahlung, error)
+	FirstOrCreate() (*model.Zahlung, error)
+	FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error)
+	ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
+	Rows() (*sql.Rows, error)
+	Row() *sql.Row
+	Scan(result interface{}) (err error)
+	Returning(value interface{}, columns ...string) IZahlungDo
+	UnderlyingDB() *gorm.DB
+	schema.Tabler
+}
+
+func (z zahlungDo) Debug() IZahlungDo {
+	return z.withDO(z.DO.Debug())
+}
+
+func (z zahlungDo) WithContext(ctx context.Context) IZahlungDo {
+	return z.withDO(z.DO.WithContext(ctx))
+}
+
+func (z zahlungDo) ReadDB() IZahlungDo {
+	return z.Clauses(dbresolver.Read)
+}
+
+func (z zahlungDo) WriteDB() IZahlungDo {
+	return z.Clauses(dbresolver.Write)
+}
+
+func (z zahlungDo) Session(config *gorm.Session) IZahlungDo {
+	return z.withDO(z.DO.Session(config))
+}
+
+func (z zahlungDo) Clauses(conds ...clause.Expression) IZahlungDo {
+	return z.withDO(z.DO.Clauses(conds...))
+}
+
+func (z zahlungDo) Returning(value interface{}, columns ...string) IZahlungDo {
+	return z.withDO(z.DO.Returning(value, columns...))
+}
+
+func (z zahlungDo) Not(conds ...gen.Condition) IZahlungDo {
+	return z.withDO(z.DO.Not(conds...))
+}
+
+func (z zahlungDo) Or(conds ...gen.Condition) IZahlungDo {
+	return z.withDO(z.DO.Or(conds...))
+}
+
+func (z zahlungDo) Select(conds ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.Select(conds...))
+}
+
+func (z zahlungDo) Where(conds ...gen.Condition) IZahlungDo {
+	return z.withDO(z.DO.Where(conds...))
+}
+
+func (z zahlungDo) Order(conds ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.Order(conds...))
+}
+
+func (z zahlungDo) Distinct(cols ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.Distinct(cols...))
+}
+
+func (z zahlungDo) Omit(cols ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.Omit(cols...))
+}
+
+func (z zahlungDo) Join(table schema.Tabler, on ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.Join(table, on...))
+}
+
+func (z zahlungDo) LeftJoin(table schema.Tabler, on ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.LeftJoin(table, on...))
+}
+
+func (z zahlungDo) RightJoin(table schema.Tabler, on ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.RightJoin(table, on...))
+}
+
+func (z zahlungDo) Group(cols ...field.Expr) IZahlungDo {
+	return z.withDO(z.DO.Group(cols...))
+}
+
+func (z zahlungDo) Having(conds ...gen.Condition) IZahlungDo {
+	return z.withDO(z.DO.Having(conds...))
+}
+
+func (z zahlungDo) Limit(limit int) IZahlungDo {
+	return z.withDO(z.DO.Limit(limit))
+}
+
+func (z zahlungDo) Offset(offset int) IZahlungDo {
+	return z.withDO(z.DO.Offset(offset))
+}
+
+func (z zahlungDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IZahlungDo {
+	return z.withDO(z.DO.Scopes(funcs...))
+}
+
+func (z zahlungDo) Unscoped() IZahlungDo {
+	return z.withDO(z.DO.Unscoped())
+}
+
+func (z zahlungDo) Create(values ...*model.Zahlung) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return z.DO.Create(values)
+}
+
+func (z zahlungDo) CreateInBatches(values []*model.Zahlung, batchSize int) error {
+	return z.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 (z zahlungDo) Save(values ...*model.Zahlung) error {
+	if len(values) == 0 {
+		return nil
+	}
+	return z.DO.Save(values)
+}
+
+func (z zahlungDo) First() (*model.Zahlung, error) {
+	if result, err := z.DO.First(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Zahlung), nil
+	}
+}
+
+func (z zahlungDo) Take() (*model.Zahlung, error) {
+	if result, err := z.DO.Take(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Zahlung), nil
+	}
+}
+
+func (z zahlungDo) Last() (*model.Zahlung, error) {
+	if result, err := z.DO.Last(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Zahlung), nil
+	}
+}
+
+func (z zahlungDo) Find() ([]*model.Zahlung, error) {
+	result, err := z.DO.Find()
+	return result.([]*model.Zahlung), err
+}
+
+func (z zahlungDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.Zahlung, err error) {
+	buf := make([]*model.Zahlung, 0, batchSize)
+	err = z.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 (z zahlungDo) FindInBatches(result *[]*model.Zahlung, batchSize int, fc func(tx gen.Dao, batch int) error) error {
+	return z.DO.FindInBatches(result, batchSize, fc)
+}
+
+func (z zahlungDo) Attrs(attrs ...field.AssignExpr) IZahlungDo {
+	return z.withDO(z.DO.Attrs(attrs...))
+}
+
+func (z zahlungDo) Assign(attrs ...field.AssignExpr) IZahlungDo {
+	return z.withDO(z.DO.Assign(attrs...))
+}
+
+func (z zahlungDo) Joins(fields ...field.RelationField) IZahlungDo {
+	for _, _f := range fields {
+		z = *z.withDO(z.DO.Joins(_f))
+	}
+	return &z
+}
+
+func (z zahlungDo) Preload(fields ...field.RelationField) IZahlungDo {
+	for _, _f := range fields {
+		z = *z.withDO(z.DO.Preload(_f))
+	}
+	return &z
+}
+
+func (z zahlungDo) FirstOrInit() (*model.Zahlung, error) {
+	if result, err := z.DO.FirstOrInit(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Zahlung), nil
+	}
+}
+
+func (z zahlungDo) FirstOrCreate() (*model.Zahlung, error) {
+	if result, err := z.DO.FirstOrCreate(); err != nil {
+		return nil, err
+	} else {
+		return result.(*model.Zahlung), nil
+	}
+}
+
+func (z zahlungDo) FindByPage(offset int, limit int) (result []*model.Zahlung, count int64, err error) {
+	result, err = z.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 = z.Offset(-1).Limit(-1).Count()
+	return
+}
+
+func (z zahlungDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
+	count, err = z.Count()
+	if err != nil {
+		return
+	}
+
+	err = z.Offset(offset).Limit(limit).Scan(result)
+	return
+}
+
+func (z zahlungDo) Scan(result interface{}) (err error) {
+	return z.DO.Scan(result)
+}
+
+func (z zahlungDo) Delete(models ...*model.Zahlung) (result gen.ResultInfo, err error) {
+	return z.DO.Delete(models)
+}
+
+func (z *zahlungDo) withDO(do gen.Dao) *zahlungDo {
+	z.DO = *do.(*gen.DO)
+	return z
+}