rts-sim-testing-service/db/dbquery/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 dbquery

import (
	"context"
	"database/sql"

	"gorm.io/gorm"

	"gorm.io/gen"

	"gorm.io/plugin/dbresolver"
)

var (
	Q                    = new(Query)
	AuthAPIPath          *authAPIPath
	AuthRole             *authRole
	AuthRoleAPIPath      *authRoleAPIPath
	AuthRoleUser         *authRoleUser
	Category             *category
	Drafting             *drafting
	Project              *project
	ProjectPublishLink   *projectPublishLink
	ProjectTrainSizeLink *projectTrainSizeLink
	PublishedGi          *publishedGi
	TrainModel           *trainModel
	TrainSize            *trainSize
	TrainWheelDiameter   *trainWheelDiameter
	User                 *user
)

func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
	*Q = *Use(db, opts...)
	AuthAPIPath = &Q.AuthAPIPath
	AuthRole = &Q.AuthRole
	AuthRoleAPIPath = &Q.AuthRoleAPIPath
	AuthRoleUser = &Q.AuthRoleUser
	Category = &Q.Category
	Drafting = &Q.Drafting
	Project = &Q.Project
	ProjectPublishLink = &Q.ProjectPublishLink
	ProjectTrainSizeLink = &Q.ProjectTrainSizeLink
	PublishedGi = &Q.PublishedGi
	TrainModel = &Q.TrainModel
	TrainSize = &Q.TrainSize
	TrainWheelDiameter = &Q.TrainWheelDiameter
	User = &Q.User
}

func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
	return &Query{
		db:                   db,
		AuthAPIPath:          newAuthAPIPath(db, opts...),
		AuthRole:             newAuthRole(db, opts...),
		AuthRoleAPIPath:      newAuthRoleAPIPath(db, opts...),
		AuthRoleUser:         newAuthRoleUser(db, opts...),
		Category:             newCategory(db, opts...),
		Drafting:             newDrafting(db, opts...),
		Project:              newProject(db, opts...),
		ProjectPublishLink:   newProjectPublishLink(db, opts...),
		ProjectTrainSizeLink: newProjectTrainSizeLink(db, opts...),
		PublishedGi:          newPublishedGi(db, opts...),
		TrainModel:           newTrainModel(db, opts...),
		TrainSize:            newTrainSize(db, opts...),
		TrainWheelDiameter:   newTrainWheelDiameter(db, opts...),
		User:                 newUser(db, opts...),
	}
}

type Query struct {
	db *gorm.DB

	AuthAPIPath          authAPIPath
	AuthRole             authRole
	AuthRoleAPIPath      authRoleAPIPath
	AuthRoleUser         authRoleUser
	Category             category
	Drafting             drafting
	Project              project
	ProjectPublishLink   projectPublishLink
	ProjectTrainSizeLink projectTrainSizeLink
	PublishedGi          publishedGi
	TrainModel           trainModel
	TrainSize            trainSize
	TrainWheelDiameter   trainWheelDiameter
	User                 user
}

func (q *Query) Available() bool { return q.db != nil }

func (q *Query) clone(db *gorm.DB) *Query {
	return &Query{
		db:                   db,
		AuthAPIPath:          q.AuthAPIPath.clone(db),
		AuthRole:             q.AuthRole.clone(db),
		AuthRoleAPIPath:      q.AuthRoleAPIPath.clone(db),
		AuthRoleUser:         q.AuthRoleUser.clone(db),
		Category:             q.Category.clone(db),
		Drafting:             q.Drafting.clone(db),
		Project:              q.Project.clone(db),
		ProjectPublishLink:   q.ProjectPublishLink.clone(db),
		ProjectTrainSizeLink: q.ProjectTrainSizeLink.clone(db),
		PublishedGi:          q.PublishedGi.clone(db),
		TrainModel:           q.TrainModel.clone(db),
		TrainSize:            q.TrainSize.clone(db),
		TrainWheelDiameter:   q.TrainWheelDiameter.clone(db),
		User:                 q.User.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,
		AuthAPIPath:          q.AuthAPIPath.replaceDB(db),
		AuthRole:             q.AuthRole.replaceDB(db),
		AuthRoleAPIPath:      q.AuthRoleAPIPath.replaceDB(db),
		AuthRoleUser:         q.AuthRoleUser.replaceDB(db),
		Category:             q.Category.replaceDB(db),
		Drafting:             q.Drafting.replaceDB(db),
		Project:              q.Project.replaceDB(db),
		ProjectPublishLink:   q.ProjectPublishLink.replaceDB(db),
		ProjectTrainSizeLink: q.ProjectTrainSizeLink.replaceDB(db),
		PublishedGi:          q.PublishedGi.replaceDB(db),
		TrainModel:           q.TrainModel.replaceDB(db),
		TrainSize:            q.TrainSize.replaceDB(db),
		TrainWheelDiameter:   q.TrainWheelDiameter.replaceDB(db),
		User:                 q.User.replaceDB(db),
	}
}

type queryCtx struct {
	AuthAPIPath          IAuthAPIPathDo
	AuthRole             IAuthRoleDo
	AuthRoleAPIPath      IAuthRoleAPIPathDo
	AuthRoleUser         IAuthRoleUserDo
	Category             ICategoryDo
	Drafting             IDraftingDo
	Project              IProjectDo
	ProjectPublishLink   IProjectPublishLinkDo
	ProjectTrainSizeLink IProjectTrainSizeLinkDo
	PublishedGi          IPublishedGiDo
	TrainModel           ITrainModelDo
	TrainSize            ITrainSizeDo
	TrainWheelDiameter   ITrainWheelDiameterDo
	User                 IUserDo
}

func (q *Query) WithContext(ctx context.Context) *queryCtx {
	return &queryCtx{
		AuthAPIPath:          q.AuthAPIPath.WithContext(ctx),
		AuthRole:             q.AuthRole.WithContext(ctx),
		AuthRoleAPIPath:      q.AuthRoleAPIPath.WithContext(ctx),
		AuthRoleUser:         q.AuthRoleUser.WithContext(ctx),
		Category:             q.Category.WithContext(ctx),
		Drafting:             q.Drafting.WithContext(ctx),
		Project:              q.Project.WithContext(ctx),
		ProjectPublishLink:   q.ProjectPublishLink.WithContext(ctx),
		ProjectTrainSizeLink: q.ProjectTrainSizeLink.WithContext(ctx),
		PublishedGi:          q.PublishedGi.WithContext(ctx),
		TrainModel:           q.TrainModel.WithContext(ctx),
		TrainSize:            q.TrainSize.WithContext(ctx),
		TrainWheelDiameter:   q.TrainWheelDiameter.WithContext(ctx),
		User:                 q.User.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
}