vt/query/gen.go

// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.
// Code generated by gorm.io/gen. DO NOT EDIT.

package query

import (
	"context"
	"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
}