youtu/youtu_server
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更新dao层

Browse Source
This commit is contained in:
xiabin 2025-01-25 18:19:07 +08:00
parent 9de52d82b0
commit 150e241c4d
13 changed files with 476 additions and 1974 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
game_open_api/internal/svc/service_context.go
View File

@ -6,7 +6,7 @@ import (
"errors" "errors"
"gitea.youtukeji.com.cn/xiabin/youtu_server/game_open_api/internal/config" "gitea.youtukeji.com.cn/xiabin/youtu_server/game_open_api/internal/config"
"gitea.youtukeji.com.cn/xiabin/youtu_server/game_open_api/internal/logic/rankings" "gitea.youtukeji.com.cn/xiabin/youtu_server/game_open_api/internal/logic/rankings"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/query" "gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/query"
redisCacher "gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/redis" redisCacher "gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/redis"
helper "gitea.youtukeji.com.cn/youtu/openapi-helper" helper "gitea.youtukeji.com.cn/youtu/openapi-helper"
"github.com/go-gorm/caches/v4" "github.com/go-gorm/caches/v4"

15
gorm-gen/dao/model/game_score.gen.go
View File

@ -4,15 +4,20 @@
package model package model
import (
"time"
)
const TableNameGameScore = "game_score" const TableNameGameScore = "game_score"
// GameScore mapped from table <game_score> // GameScore mapped from table <game_score>
type GameScore struct { type GameScore struct {
ID uint64 `gorm:"column:id;type:bigint unsigned;primaryKey;autoIncrement:true" json:"id"` ID uint64 `gorm:"column:id;type:bigint unsigned;primaryKey;autoIncrement:true" json:"id"`
AppAccount uint32 `gorm:"column:app_account;type:int unsigned;not null;uniqueIndex:rank_list,priority:1;comment:小游戏id" json:"app_account"` // 小游戏id AppAccount uint32 `gorm:"column:app_account;type:int unsigned;not null;uniqueIndex:rank_list,priority:1;comment:小游戏id" json:"app_account"` // 小游戏id
AppUserID uint64 `gorm:"column:app_user_id;type:bigint unsigned;not null;uniqueIndex:rank_list,priority:3;index:user_id,priority:1;comment:用户id" json:"app_user_id"` // 用户id AppUserID uint64 `gorm:"column:app_user_id;type:bigint unsigned;not null;uniqueIndex:rank_list,priority:3;index:user_id,priority:1;comment:用户id" json:"app_user_id"` // 用户id
Score uint32 `gorm:"column:score;type:int unsigned;not null;comment:得分" json:"score"` // 得分 Score uint32 `gorm:"column:score;type:int unsigned;not null;comment:得分" json:"score"` // 得分
T uint32 `gorm:"column:t;type:tinyint unsigned;not null;uniqueIndex:rank_list,priority:2;comment:得分类型(区分相同小游戏中的不同模式得分)" json:"t"` // 得分类型(区分相同小游戏中的不同模式得分) T uint32 `gorm:"column:t;type:tinyint unsigned;not null;uniqueIndex:rank_list,priority:2;comment:得分类型(区分相同小游戏中的不同模式得分)" json:"t"` // 得分类型(区分相同小游戏中的不同模式得分)
UpdatedAt time.Time `gorm:"column:updated_at;type:timestamp;not null;default:CURRENT_TIMESTAMP;comment:更新时间" json:"updated_at"` // 更新时间
} }
// TableName GameScore's table name // TableName GameScore's table name

148
gorm-gen/dao/query/app_account.gen.go
View File

@ -6,6 +6,7 @@ package query
import ( import (
"context" "context"
"strings"
"gorm.io/gorm" "gorm.io/gorm"
"gorm.io/gorm/clause" "gorm.io/gorm/clause"
@ -40,14 +41,14 @@ func newAppAccount(db *gorm.DB, opts ...gen.DOOption) appAccount {
} }
type appAccount struct { type appAccount struct {
appAccountDo appAccountDo appAccountDo
ALL field.Asterisk ALL field.Asterisk
ID field.Uint32 ID field.Uint32
Type field.Uint32 // 类型(0:抖音,1:微信) Type field.Uint32
AppID field.String AppID field.String
Secret field.String Secret field.String
Remark field.String // 备注 Remark field.String
DeletedAt field.Field DeletedAt field.Field
fieldMap map[string]field.Expr fieldMap map[string]field.Expr
@ -77,16 +78,6 @@ func (a *appAccount) updateTableName(table string) *appAccount {
return a return a
} }
func (a *appAccount) WithContext(ctx context.Context) *appAccountDo {
return a.appAccountDo.WithContext(ctx)
}
func (a appAccount) TableName() string { return a.appAccountDo.TableName() }
func (a appAccount) Alias() string { return a.appAccountDo.Alias() }
func (a appAccount) Columns(cols ...field.Expr) gen.Columns { return a.appAccountDo.Columns(cols...) }
func (a *appAccount) GetFieldByName(fieldName string) (field.OrderExpr, bool) { func (a *appAccount) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := a.fieldMap[fieldName] _f, ok := a.fieldMap[fieldName]
if !ok || _f == nil { if !ok || _f == nil {
@ -118,95 +109,172 @@ func (a appAccount) replaceDB(db *gorm.DB) appAccount {
type appAccountDo struct{ gen.DO } type appAccountDo struct{ gen.DO }
func (a appAccountDo) Debug() *appAccountDo { type IAppAccountDo interface {
gen.SubQuery
Debug() IAppAccountDo
WithContext(ctx context.Context) IAppAccountDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IAppAccountDo
WriteDB() IAppAccountDo
As(alias string) gen.Dao
Session(config *gorm.Session) IAppAccountDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IAppAccountDo
Not(conds ...gen.Condition) IAppAccountDo
Or(conds ...gen.Condition) IAppAccountDo
Select(conds ...field.Expr) IAppAccountDo
Where(conds ...gen.Condition) IAppAccountDo
Order(conds ...field.Expr) IAppAccountDo
Distinct(cols ...field.Expr) IAppAccountDo
Omit(cols ...field.Expr) IAppAccountDo
Join(table schema.Tabler, on ...field.Expr) IAppAccountDo
LeftJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo
RightJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo
Group(cols ...field.Expr) IAppAccountDo
Having(conds ...gen.Condition) IAppAccountDo
Limit(limit int) IAppAccountDo
Offset(offset int) IAppAccountDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IAppAccountDo
Unscoped() IAppAccountDo
Create(values ...*model.AppAccount) error
CreateInBatches(values []*model.AppAccount, batchSize int) error
Save(values ...*model.AppAccount) error
First() (*model.AppAccount, error)
Take() (*model.AppAccount, error)
Last() (*model.AppAccount, error)
Find() ([]*model.AppAccount, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppAccount, err error)
FindInBatches(result *[]*model.AppAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.AppAccount) (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) IAppAccountDo
Assign(attrs ...field.AssignExpr) IAppAccountDo
Joins(fields ...field.RelationField) IAppAccountDo
Preload(fields ...field.RelationField) IAppAccountDo
FirstOrInit() (*model.AppAccount, error)
FirstOrCreate() (*model.AppAccount, error)
FindByPage(offset int, limit int) (result []*model.AppAccount, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IAppAccountDo
UnderlyingDB() *gorm.DB
schema.Tabler
GetAppConfig() (result []*model.AppAccount, err error)
}
// GetAppConfig 获取所有小游戏配置
//
// select `app_id`,`secret`,`ecpm_value`,`ecpm_view`,`type` from `app_account` left join douyin_ecpm_config on app_account.id = douyin_ecpm_config.app_account_id
func (a appAccountDo) GetAppConfig() (result []*model.AppAccount, err error) {
var generateSQL strings.Builder
generateSQL.WriteString("select `app_id`,`secret`,`ecpm_value`,`ecpm_view`,`type` from `app_account` left join douyin_ecpm_config on app_account.id = douyin_ecpm_config.app_account_id ")
var executeSQL *gorm.DB
executeSQL = a.UnderlyingDB().Raw(generateSQL.String()).Find(&result) // ignore_security_alert
err = executeSQL.Error
return
}
func (a appAccountDo) Debug() IAppAccountDo {
return a.withDO(a.DO.Debug()) return a.withDO(a.DO.Debug())
} }
func (a appAccountDo) WithContext(ctx context.Context) *appAccountDo { func (a appAccountDo) WithContext(ctx context.Context) IAppAccountDo {
return a.withDO(a.DO.WithContext(ctx)) return a.withDO(a.DO.WithContext(ctx))
} }
func (a appAccountDo) ReadDB() *appAccountDo { func (a appAccountDo) ReadDB() IAppAccountDo {
return a.Clauses(dbresolver.Read) return a.Clauses(dbresolver.Read)
} }
func (a appAccountDo) WriteDB() *appAccountDo { func (a appAccountDo) WriteDB() IAppAccountDo {
return a.Clauses(dbresolver.Write) return a.Clauses(dbresolver.Write)
} }
func (a appAccountDo) Session(config *gorm.Session) *appAccountDo { func (a appAccountDo) Session(config *gorm.Session) IAppAccountDo {
return a.withDO(a.DO.Session(config)) return a.withDO(a.DO.Session(config))
} }
func (a appAccountDo) Clauses(conds ...clause.Expression) *appAccountDo { func (a appAccountDo) Clauses(conds ...clause.Expression) IAppAccountDo {
return a.withDO(a.DO.Clauses(conds...)) return a.withDO(a.DO.Clauses(conds...))
} }
func (a appAccountDo) Returning(value interface{}, columns ...string) *appAccountDo { func (a appAccountDo) Returning(value interface{}, columns ...string) IAppAccountDo {
return a.withDO(a.DO.Returning(value, columns...)) return a.withDO(a.DO.Returning(value, columns...))
} }
func (a appAccountDo) Not(conds ...gen.Condition) *appAccountDo { func (a appAccountDo) Not(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Not(conds...)) return a.withDO(a.DO.Not(conds...))
} }
func (a appAccountDo) Or(conds ...gen.Condition) *appAccountDo { func (a appAccountDo) Or(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Or(conds...)) return a.withDO(a.DO.Or(conds...))
} }
func (a appAccountDo) Select(conds ...field.Expr) *appAccountDo { func (a appAccountDo) Select(conds ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Select(conds...)) return a.withDO(a.DO.Select(conds...))
} }
func (a appAccountDo) Where(conds ...gen.Condition) *appAccountDo { func (a appAccountDo) Where(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Where(conds...)) return a.withDO(a.DO.Where(conds...))
} }
func (a appAccountDo) Order(conds ...field.Expr) *appAccountDo { func (a appAccountDo) Order(conds ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Order(conds...)) return a.withDO(a.DO.Order(conds...))
} }
func (a appAccountDo) Distinct(cols ...field.Expr) *appAccountDo { func (a appAccountDo) Distinct(cols ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Distinct(cols...)) return a.withDO(a.DO.Distinct(cols...))
} }
func (a appAccountDo) Omit(cols ...field.Expr) *appAccountDo { func (a appAccountDo) Omit(cols ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Omit(cols...)) return a.withDO(a.DO.Omit(cols...))
} }
func (a appAccountDo) Join(table schema.Tabler, on ...field.Expr) *appAccountDo { func (a appAccountDo) Join(table schema.Tabler, on ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Join(table, on...)) return a.withDO(a.DO.Join(table, on...))
} }
func (a appAccountDo) LeftJoin(table schema.Tabler, on ...field.Expr) *appAccountDo { func (a appAccountDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.LeftJoin(table, on...)) return a.withDO(a.DO.LeftJoin(table, on...))
} }
func (a appAccountDo) RightJoin(table schema.Tabler, on ...field.Expr) *appAccountDo { func (a appAccountDo) RightJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.RightJoin(table, on...)) return a.withDO(a.DO.RightJoin(table, on...))
} }
func (a appAccountDo) Group(cols ...field.Expr) *appAccountDo { func (a appAccountDo) Group(cols ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Group(cols...)) return a.withDO(a.DO.Group(cols...))
} }
func (a appAccountDo) Having(conds ...gen.Condition) *appAccountDo { func (a appAccountDo) Having(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Having(conds...)) return a.withDO(a.DO.Having(conds...))
} }
func (a appAccountDo) Limit(limit int) *appAccountDo { func (a appAccountDo) Limit(limit int) IAppAccountDo {
return a.withDO(a.DO.Limit(limit)) return a.withDO(a.DO.Limit(limit))
} }
func (a appAccountDo) Offset(offset int) *appAccountDo { func (a appAccountDo) Offset(offset int) IAppAccountDo {
return a.withDO(a.DO.Offset(offset)) return a.withDO(a.DO.Offset(offset))
} }
func (a appAccountDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *appAccountDo { func (a appAccountDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAppAccountDo {
return a.withDO(a.DO.Scopes(funcs...)) return a.withDO(a.DO.Scopes(funcs...))
} }
func (a appAccountDo) Unscoped() *appAccountDo { func (a appAccountDo) Unscoped() IAppAccountDo {
return a.withDO(a.DO.Unscoped()) return a.withDO(a.DO.Unscoped())
} }
@ -272,22 +340,22 @@ func (a appAccountDo) FindInBatches(result *[]*model.AppAccount, batchSize int,
return a.DO.FindInBatches(result, batchSize, fc) return a.DO.FindInBatches(result, batchSize, fc)
} }
func (a appAccountDo) Attrs(attrs ...field.AssignExpr) *appAccountDo { func (a appAccountDo) Attrs(attrs ...field.AssignExpr) IAppAccountDo {
return a.withDO(a.DO.Attrs(attrs...)) return a.withDO(a.DO.Attrs(attrs...))
} }
func (a appAccountDo) Assign(attrs ...field.AssignExpr) *appAccountDo { func (a appAccountDo) Assign(attrs ...field.AssignExpr) IAppAccountDo {
return a.withDO(a.DO.Assign(attrs...)) return a.withDO(a.DO.Assign(attrs...))
} }
func (a appAccountDo) Joins(fields ...field.RelationField) *appAccountDo { func (a appAccountDo) Joins(fields ...field.RelationField) IAppAccountDo {
for _, _f := range fields { for _, _f := range fields {
a = *a.withDO(a.DO.Joins(_f)) a = *a.withDO(a.DO.Joins(_f))
} }
return &a return &a
} }
func (a appAccountDo) Preload(fields ...field.RelationField) *appAccountDo { func (a appAccountDo) Preload(fields ...field.RelationField) IAppAccountDo {
for _, _f := range fields { for _, _f := range fields {
a = *a.withDO(a.DO.Preload(_f)) a = *a.withDO(a.DO.Preload(_f))
} }

137
gorm-gen/dao/query/app_user.gen.go
View File

@ -43,18 +43,18 @@ func newAppUser(db *gorm.DB, opts ...gen.DOOption) appUser {
} }
type appUser struct { type appUser struct {
appUserDo appUserDo appUserDo
ALL field.Asterisk ALL field.Asterisk
ID field.Uint64 ID field.Uint64
AppAccountID field.Uint32 // app_account表外键 AppAccountID field.Uint32
Openid field.String Openid field.String
Unionid field.String Unionid field.String
Nickname field.String // 昵称 Nickname field.String
Avatar field.String // 头像 Avatar field.String
AnonymousOpenid field.String // 匿名openid AnonymousOpenid field.String
CreatedAt field.Time // 创建时间 CreatedAt field.Time
UpdatedAt field.Time // 更新时间 UpdatedAt field.Time
fieldMap map[string]field.Expr fieldMap map[string]field.Expr
} }
@ -86,14 +86,6 @@ func (a *appUser) updateTableName(table string) *appUser {
return a return a
} }
func (a *appUser) WithContext(ctx context.Context) *appUserDo { return a.appUserDo.WithContext(ctx) }
func (a appUser) TableName() string { return a.appUserDo.TableName() }
func (a appUser) Alias() string { return a.appUserDo.Alias() }
func (a appUser) Columns(cols ...field.Expr) gen.Columns { return a.appUserDo.Columns(cols...) }
func (a *appUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) { func (a *appUser) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := a.fieldMap[fieldName] _f, ok := a.fieldMap[fieldName]
if !ok || _f == nil { if !ok || _f == nil {
@ -128,95 +120,156 @@ func (a appUser) replaceDB(db *gorm.DB) appUser {
type appUserDo struct{ gen.DO } type appUserDo struct{ gen.DO }
func (a appUserDo) Debug() *appUserDo { type IAppUserDo interface {
gen.SubQuery
Debug() IAppUserDo
WithContext(ctx context.Context) IAppUserDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IAppUserDo
WriteDB() IAppUserDo
As(alias string) gen.Dao
Session(config *gorm.Session) IAppUserDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IAppUserDo
Not(conds ...gen.Condition) IAppUserDo
Or(conds ...gen.Condition) IAppUserDo
Select(conds ...field.Expr) IAppUserDo
Where(conds ...gen.Condition) IAppUserDo
Order(conds ...field.Expr) IAppUserDo
Distinct(cols ...field.Expr) IAppUserDo
Omit(cols ...field.Expr) IAppUserDo
Join(table schema.Tabler, on ...field.Expr) IAppUserDo
LeftJoin(table schema.Tabler, on ...field.Expr) IAppUserDo
RightJoin(table schema.Tabler, on ...field.Expr) IAppUserDo
Group(cols ...field.Expr) IAppUserDo
Having(conds ...gen.Condition) IAppUserDo
Limit(limit int) IAppUserDo
Offset(offset int) IAppUserDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IAppUserDo
Unscoped() IAppUserDo
Create(values ...*model.AppUser) error
CreateInBatches(values []*model.AppUser, batchSize int) error
Save(values ...*model.AppUser) error
First() (*model.AppUser, error)
Take() (*model.AppUser, error)
Last() (*model.AppUser, error)
Find() ([]*model.AppUser, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppUser, err error)
FindInBatches(result *[]*model.AppUser, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.AppUser) (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) IAppUserDo
Assign(attrs ...field.AssignExpr) IAppUserDo
Joins(fields ...field.RelationField) IAppUserDo
Preload(fields ...field.RelationField) IAppUserDo
FirstOrInit() (*model.AppUser, error)
FirstOrCreate() (*model.AppUser, error)
FindByPage(offset int, limit int) (result []*model.AppUser, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IAppUserDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (a appUserDo) Debug() IAppUserDo {
return a.withDO(a.DO.Debug()) return a.withDO(a.DO.Debug())
} }
func (a appUserDo) WithContext(ctx context.Context) *appUserDo { func (a appUserDo) WithContext(ctx context.Context) IAppUserDo {
return a.withDO(a.DO.WithContext(ctx)) return a.withDO(a.DO.WithContext(ctx))
} }
func (a appUserDo) ReadDB() *appUserDo { func (a appUserDo) ReadDB() IAppUserDo {
return a.Clauses(dbresolver.Read) return a.Clauses(dbresolver.Read)
} }
func (a appUserDo) WriteDB() *appUserDo { func (a appUserDo) WriteDB() IAppUserDo {
return a.Clauses(dbresolver.Write) return a.Clauses(dbresolver.Write)
} }
func (a appUserDo) Session(config *gorm.Session) *appUserDo { func (a appUserDo) Session(config *gorm.Session) IAppUserDo {
return a.withDO(a.DO.Session(config)) return a.withDO(a.DO.Session(config))
} }
func (a appUserDo) Clauses(conds ...clause.Expression) *appUserDo { func (a appUserDo) Clauses(conds ...clause.Expression) IAppUserDo {
return a.withDO(a.DO.Clauses(conds...)) return a.withDO(a.DO.Clauses(conds...))
} }
func (a appUserDo) Returning(value interface{}, columns ...string) *appUserDo { func (a appUserDo) Returning(value interface{}, columns ...string) IAppUserDo {
return a.withDO(a.DO.Returning(value, columns...)) return a.withDO(a.DO.Returning(value, columns...))
} }
func (a appUserDo) Not(conds ...gen.Condition) *appUserDo { func (a appUserDo) Not(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Not(conds...)) return a.withDO(a.DO.Not(conds...))
} }
func (a appUserDo) Or(conds ...gen.Condition) *appUserDo { func (a appUserDo) Or(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Or(conds...)) return a.withDO(a.DO.Or(conds...))
} }
func (a appUserDo) Select(conds ...field.Expr) *appUserDo { func (a appUserDo) Select(conds ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Select(conds...)) return a.withDO(a.DO.Select(conds...))
} }
func (a appUserDo) Where(conds ...gen.Condition) *appUserDo { func (a appUserDo) Where(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Where(conds...)) return a.withDO(a.DO.Where(conds...))
} }
func (a appUserDo) Order(conds ...field.Expr) *appUserDo { func (a appUserDo) Order(conds ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Order(conds...)) return a.withDO(a.DO.Order(conds...))
} }
func (a appUserDo) Distinct(cols ...field.Expr) *appUserDo { func (a appUserDo) Distinct(cols ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Distinct(cols...)) return a.withDO(a.DO.Distinct(cols...))
} }
func (a appUserDo) Omit(cols ...field.Expr) *appUserDo { func (a appUserDo) Omit(cols ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Omit(cols...)) return a.withDO(a.DO.Omit(cols...))
} }
func (a appUserDo) Join(table schema.Tabler, on ...field.Expr) *appUserDo { func (a appUserDo) Join(table schema.Tabler, on ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Join(table, on...)) return a.withDO(a.DO.Join(table, on...))
} }
func (a appUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) *appUserDo { func (a appUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAppUserDo {
return a.withDO(a.DO.LeftJoin(table, on...)) return a.withDO(a.DO.LeftJoin(table, on...))
} }
func (a appUserDo) RightJoin(table schema.Tabler, on ...field.Expr) *appUserDo { func (a appUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IAppUserDo {
return a.withDO(a.DO.RightJoin(table, on...)) return a.withDO(a.DO.RightJoin(table, on...))
} }
func (a appUserDo) Group(cols ...field.Expr) *appUserDo { func (a appUserDo) Group(cols ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Group(cols...)) return a.withDO(a.DO.Group(cols...))
} }
func (a appUserDo) Having(conds ...gen.Condition) *appUserDo { func (a appUserDo) Having(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Having(conds...)) return a.withDO(a.DO.Having(conds...))
} }
func (a appUserDo) Limit(limit int) *appUserDo { func (a appUserDo) Limit(limit int) IAppUserDo {
return a.withDO(a.DO.Limit(limit)) return a.withDO(a.DO.Limit(limit))
} }
func (a appUserDo) Offset(offset int) *appUserDo { func (a appUserDo) Offset(offset int) IAppUserDo {
return a.withDO(a.DO.Offset(offset)) return a.withDO(a.DO.Offset(offset))
} }
func (a appUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *appUserDo { func (a appUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAppUserDo {
return a.withDO(a.DO.Scopes(funcs...)) return a.withDO(a.DO.Scopes(funcs...))
} }
func (a appUserDo) Unscoped() *appUserDo { func (a appUserDo) Unscoped() IAppUserDo {
return a.withDO(a.DO.Unscoped()) return a.withDO(a.DO.Unscoped())
} }
@ -282,22 +335,22 @@ func (a appUserDo) FindInBatches(result *[]*model.AppUser, batchSize int, fc fun
return a.DO.FindInBatches(result, batchSize, fc) return a.DO.FindInBatches(result, batchSize, fc)
} }
func (a appUserDo) Attrs(attrs ...field.AssignExpr) *appUserDo { func (a appUserDo) Attrs(attrs ...field.AssignExpr) IAppUserDo {
return a.withDO(a.DO.Attrs(attrs...)) return a.withDO(a.DO.Attrs(attrs...))
} }
func (a appUserDo) Assign(attrs ...field.AssignExpr) *appUserDo { func (a appUserDo) Assign(attrs ...field.AssignExpr) IAppUserDo {
return a.withDO(a.DO.Assign(attrs...)) return a.withDO(a.DO.Assign(attrs...))
} }
func (a appUserDo) Joins(fields ...field.RelationField) *appUserDo { func (a appUserDo) Joins(fields ...field.RelationField) IAppUserDo {
for _, _f := range fields { for _, _f := range fields {
a = *a.withDO(a.DO.Joins(_f)) a = *a.withDO(a.DO.Joins(_f))
} }
return &a return &a
} }
func (a appUserDo) Preload(fields ...field.RelationField) *appUserDo { func (a appUserDo) Preload(fields ...field.RelationField) IAppUserDo {
for _, _f := range fields { for _, _f := range fields {
a = *a.withDO(a.DO.Preload(_f)) a = *a.withDO(a.DO.Preload(_f))
} }

133
gorm-gen/dao/query/douyin_ecpm_config.gen.go
View File

@ -38,13 +38,13 @@ func newDouyinEcpmConfig(db *gorm.DB, opts ...gen.DOOption) douyinEcpmConfig {
} }
type douyinEcpmConfig struct { type douyinEcpmConfig struct {
douyinEcpmConfigDo douyinEcpmConfigDo douyinEcpmConfigDo
ALL field.Asterisk ALL field.Asterisk
ID field.Uint32 ID field.Uint32
AppAccountID field.Uint32 AppAccountID field.Uint32
EcpmValue field.Uint32 // 值 EcpmValue field.Uint32
EcpmView field.Uint32 // 浏览次数 EcpmView field.Uint32
fieldMap map[string]field.Expr fieldMap map[string]field.Expr
} }
@ -71,18 +71,6 @@ func (d *douyinEcpmConfig) updateTableName(table string) *douyinEcpmConfig {
return d return d
} }
func (d *douyinEcpmConfig) WithContext(ctx context.Context) *douyinEcpmConfigDo {
return d.douyinEcpmConfigDo.WithContext(ctx)
}
func (d douyinEcpmConfig) TableName() string { return d.douyinEcpmConfigDo.TableName() }
func (d douyinEcpmConfig) Alias() string { return d.douyinEcpmConfigDo.Alias() }
func (d douyinEcpmConfig) Columns(cols ...field.Expr) gen.Columns {
return d.douyinEcpmConfigDo.Columns(cols...)
}
func (d *douyinEcpmConfig) GetFieldByName(fieldName string) (field.OrderExpr, bool) { func (d *douyinEcpmConfig) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := d.fieldMap[fieldName] _f, ok := d.fieldMap[fieldName]
if !ok || _f == nil { if !ok || _f == nil {
@ -112,95 +100,156 @@ func (d douyinEcpmConfig) replaceDB(db *gorm.DB) douyinEcpmConfig {
type douyinEcpmConfigDo struct{ gen.DO } type douyinEcpmConfigDo struct{ gen.DO }
func (d douyinEcpmConfigDo) Debug() *douyinEcpmConfigDo { type IDouyinEcpmConfigDo interface {
gen.SubQuery
Debug() IDouyinEcpmConfigDo
WithContext(ctx context.Context) IDouyinEcpmConfigDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IDouyinEcpmConfigDo
WriteDB() IDouyinEcpmConfigDo
As(alias string) gen.Dao
Session(config *gorm.Session) IDouyinEcpmConfigDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IDouyinEcpmConfigDo
Not(conds ...gen.Condition) IDouyinEcpmConfigDo
Or(conds ...gen.Condition) IDouyinEcpmConfigDo
Select(conds ...field.Expr) IDouyinEcpmConfigDo
Where(conds ...gen.Condition) IDouyinEcpmConfigDo
Order(conds ...field.Expr) IDouyinEcpmConfigDo
Distinct(cols ...field.Expr) IDouyinEcpmConfigDo
Omit(cols ...field.Expr) IDouyinEcpmConfigDo
Join(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo
LeftJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo
RightJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo
Group(cols ...field.Expr) IDouyinEcpmConfigDo
Having(conds ...gen.Condition) IDouyinEcpmConfigDo
Limit(limit int) IDouyinEcpmConfigDo
Offset(offset int) IDouyinEcpmConfigDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IDouyinEcpmConfigDo
Unscoped() IDouyinEcpmConfigDo
Create(values ...*model.DouyinEcpmConfig) error
CreateInBatches(values []*model.DouyinEcpmConfig, batchSize int) error
Save(values ...*model.DouyinEcpmConfig) error
First() (*model.DouyinEcpmConfig, error)
Take() (*model.DouyinEcpmConfig, error)
Last() (*model.DouyinEcpmConfig, error)
Find() ([]*model.DouyinEcpmConfig, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DouyinEcpmConfig, err error)
FindInBatches(result *[]*model.DouyinEcpmConfig, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.DouyinEcpmConfig) (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) IDouyinEcpmConfigDo
Assign(attrs ...field.AssignExpr) IDouyinEcpmConfigDo
Joins(fields ...field.RelationField) IDouyinEcpmConfigDo
Preload(fields ...field.RelationField) IDouyinEcpmConfigDo
FirstOrInit() (*model.DouyinEcpmConfig, error)
FirstOrCreate() (*model.DouyinEcpmConfig, error)
FindByPage(offset int, limit int) (result []*model.DouyinEcpmConfig, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IDouyinEcpmConfigDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (d douyinEcpmConfigDo) Debug() IDouyinEcpmConfigDo {
return d.withDO(d.DO.Debug()) return d.withDO(d.DO.Debug())
} }
func (d douyinEcpmConfigDo) WithContext(ctx context.Context) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) WithContext(ctx context.Context) IDouyinEcpmConfigDo {
return d.withDO(d.DO.WithContext(ctx)) return d.withDO(d.DO.WithContext(ctx))
} }
func (d douyinEcpmConfigDo) ReadDB() *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) ReadDB() IDouyinEcpmConfigDo {
return d.Clauses(dbresolver.Read) return d.Clauses(dbresolver.Read)
} }
func (d douyinEcpmConfigDo) WriteDB() *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) WriteDB() IDouyinEcpmConfigDo {
return d.Clauses(dbresolver.Write) return d.Clauses(dbresolver.Write)
} }
func (d douyinEcpmConfigDo) Session(config *gorm.Session) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Session(config *gorm.Session) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Session(config)) return d.withDO(d.DO.Session(config))
} }
func (d douyinEcpmConfigDo) Clauses(conds ...clause.Expression) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Clauses(conds ...clause.Expression) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Clauses(conds...)) return d.withDO(d.DO.Clauses(conds...))
} }
func (d douyinEcpmConfigDo) Returning(value interface{}, columns ...string) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Returning(value interface{}, columns ...string) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Returning(value, columns...)) return d.withDO(d.DO.Returning(value, columns...))
} }
func (d douyinEcpmConfigDo) Not(conds ...gen.Condition) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Not(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Not(conds...)) return d.withDO(d.DO.Not(conds...))
} }
func (d douyinEcpmConfigDo) Or(conds ...gen.Condition) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Or(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Or(conds...)) return d.withDO(d.DO.Or(conds...))
} }
func (d douyinEcpmConfigDo) Select(conds ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Select(conds ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Select(conds...)) return d.withDO(d.DO.Select(conds...))
} }
func (d douyinEcpmConfigDo) Where(conds ...gen.Condition) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Where(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Where(conds...)) return d.withDO(d.DO.Where(conds...))
} }
func (d douyinEcpmConfigDo) Order(conds ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Order(conds ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Order(conds...)) return d.withDO(d.DO.Order(conds...))
} }
func (d douyinEcpmConfigDo) Distinct(cols ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Distinct(cols ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Distinct(cols...)) return d.withDO(d.DO.Distinct(cols...))
} }
func (d douyinEcpmConfigDo) Omit(cols ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Omit(cols ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Omit(cols...)) return d.withDO(d.DO.Omit(cols...))
} }
func (d douyinEcpmConfigDo) Join(table schema.Tabler, on ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Join(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Join(table, on...)) return d.withDO(d.DO.Join(table, on...))
} }
func (d douyinEcpmConfigDo) LeftJoin(table schema.Tabler, on ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) LeftJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.LeftJoin(table, on...)) return d.withDO(d.DO.LeftJoin(table, on...))
} }
func (d douyinEcpmConfigDo) RightJoin(table schema.Tabler, on ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) RightJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.RightJoin(table, on...)) return d.withDO(d.DO.RightJoin(table, on...))
} }
func (d douyinEcpmConfigDo) Group(cols ...field.Expr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Group(cols ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Group(cols...)) return d.withDO(d.DO.Group(cols...))
} }
func (d douyinEcpmConfigDo) Having(conds ...gen.Condition) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Having(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Having(conds...)) return d.withDO(d.DO.Having(conds...))
} }
func (d douyinEcpmConfigDo) Limit(limit int) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Limit(limit int) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Limit(limit)) return d.withDO(d.DO.Limit(limit))
} }
func (d douyinEcpmConfigDo) Offset(offset int) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Offset(offset int) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Offset(offset)) return d.withDO(d.DO.Offset(offset))
} }
func (d douyinEcpmConfigDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Scopes(funcs...)) return d.withDO(d.DO.Scopes(funcs...))
} }
func (d douyinEcpmConfigDo) Unscoped() *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Unscoped() IDouyinEcpmConfigDo {
return d.withDO(d.DO.Unscoped()) return d.withDO(d.DO.Unscoped())
} }
@ -266,22 +315,22 @@ func (d douyinEcpmConfigDo) FindInBatches(result *[]*model.DouyinEcpmConfig, bat
return d.DO.FindInBatches(result, batchSize, fc) return d.DO.FindInBatches(result, batchSize, fc)
} }
func (d douyinEcpmConfigDo) Attrs(attrs ...field.AssignExpr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Attrs(attrs ...field.AssignExpr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Attrs(attrs...)) return d.withDO(d.DO.Attrs(attrs...))
} }
func (d douyinEcpmConfigDo) Assign(attrs ...field.AssignExpr) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Assign(attrs ...field.AssignExpr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Assign(attrs...)) return d.withDO(d.DO.Assign(attrs...))
} }
func (d douyinEcpmConfigDo) Joins(fields ...field.RelationField) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Joins(fields ...field.RelationField) IDouyinEcpmConfigDo {
for _, _f := range fields { for _, _f := range fields {
d = *d.withDO(d.DO.Joins(_f)) d = *d.withDO(d.DO.Joins(_f))
} }
return &d return &d
} }
func (d douyinEcpmConfigDo) Preload(fields ...field.RelationField) *douyinEcpmConfigDo { func (d douyinEcpmConfigDo) Preload(fields ...field.RelationField) IDouyinEcpmConfigDo {
for _, _f := range fields { for _, _f := range fields {
d = *d.withDO(d.DO.Preload(_f)) d = *d.withDO(d.DO.Preload(_f))
} }

193
gorm-gen/dao/query/game_score.gen.go
View File

@ -6,6 +6,7 @@ package query
import ( import (
"context" "context"
"strings"
"gorm.io/gorm" "gorm.io/gorm"
"gorm.io/gorm/clause" "gorm.io/gorm/clause"
@ -17,6 +18,7 @@ import (
"gorm.io/plugin/dbresolver" "gorm.io/plugin/dbresolver"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model" "gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/querier"
) )
func newGameScore(db *gorm.DB, opts ...gen.DOOption) gameScore { func newGameScore(db *gorm.DB, opts ...gen.DOOption) gameScore {
@ -32,6 +34,7 @@ func newGameScore(db *gorm.DB, opts ...gen.DOOption) gameScore {
_gameScore.AppUserID = field.NewUint64(tableName, "app_user_id") _gameScore.AppUserID = field.NewUint64(tableName, "app_user_id")
_gameScore.Score = field.NewUint32(tableName, "score") _gameScore.Score = field.NewUint32(tableName, "score")
_gameScore.T = field.NewUint32(tableName, "t") _gameScore.T = field.NewUint32(tableName, "t")
_gameScore.UpdatedAt = field.NewTime(tableName, "updated_at")
_gameScore.fillFieldMap() _gameScore.fillFieldMap()
@ -39,14 +42,15 @@ func newGameScore(db *gorm.DB, opts ...gen.DOOption) gameScore {
} }
type gameScore struct { type gameScore struct {
gameScoreDo gameScoreDo gameScoreDo
ALL field.Asterisk ALL field.Asterisk
ID field.Uint64 ID field.Uint64
AppAccount field.Uint32 // 小游戏id AppAccount field.Uint32
AppUserID field.Uint64 // 用户id AppUserID field.Uint64
Score field.Uint32 // 得分 Score field.Uint32
T field.Uint32 // 得分类型(区分相同小游戏中的不同模式得分) T field.Uint32
UpdatedAt field.Time
fieldMap map[string]field.Expr fieldMap map[string]field.Expr
} }
@ -68,22 +72,13 @@ func (g *gameScore) updateTableName(table string) *gameScore {
g.AppUserID = field.NewUint64(table, "app_user_id") g.AppUserID = field.NewUint64(table, "app_user_id")
g.Score = field.NewUint32(table, "score") g.Score = field.NewUint32(table, "score")
g.T = field.NewUint32(table, "t") g.T = field.NewUint32(table, "t")
g.UpdatedAt = field.NewTime(table, "updated_at")
g.fillFieldMap() g.fillFieldMap()
return g return g
} }
func (g *gameScore) WithContext(ctx context.Context) *gameScoreDo {
return g.gameScoreDo.WithContext(ctx)
}
func (g gameScore) TableName() string { return g.gameScoreDo.TableName() }
func (g gameScore) Alias() string { return g.gameScoreDo.Alias() }
func (g gameScore) Columns(cols ...field.Expr) gen.Columns { return g.gameScoreDo.Columns(cols...) }
func (g *gameScore) GetFieldByName(fieldName string) (field.OrderExpr, bool) { func (g *gameScore) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := g.fieldMap[fieldName] _f, ok := g.fieldMap[fieldName]
if !ok || _f == nil { if !ok || _f == nil {
@ -94,12 +89,13 @@ func (g *gameScore) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
} }
func (g *gameScore) fillFieldMap() { func (g *gameScore) fillFieldMap() {
g.fieldMap = make(map[string]field.Expr, 5) g.fieldMap = make(map[string]field.Expr, 6)
g.fieldMap["id"] = g.ID g.fieldMap["id"] = g.ID
g.fieldMap["app_account"] = g.AppAccount g.fieldMap["app_account"] = g.AppAccount
g.fieldMap["app_user_id"] = g.AppUserID g.fieldMap["app_user_id"] = g.AppUserID
g.fieldMap["score"] = g.Score g.fieldMap["score"] = g.Score
g.fieldMap["t"] = g.T g.fieldMap["t"] = g.T
g.fieldMap["updated_at"] = g.UpdatedAt
} }
func (g gameScore) clone(db *gorm.DB) gameScore { func (g gameScore) clone(db *gorm.DB) gameScore {
@ -114,95 +110,206 @@ func (g gameScore) replaceDB(db *gorm.DB) gameScore {
type gameScoreDo struct{ gen.DO } type gameScoreDo struct{ gen.DO }
func (g gameScoreDo) Debug() *gameScoreDo { type IGameScoreDo interface {
gen.SubQuery
Debug() IGameScoreDo
WithContext(ctx context.Context) IGameScoreDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IGameScoreDo
WriteDB() IGameScoreDo
As(alias string) gen.Dao
Session(config *gorm.Session) IGameScoreDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IGameScoreDo
Not(conds ...gen.Condition) IGameScoreDo
Or(conds ...gen.Condition) IGameScoreDo
Select(conds ...field.Expr) IGameScoreDo
Where(conds ...gen.Condition) IGameScoreDo
Order(conds ...field.Expr) IGameScoreDo
Distinct(cols ...field.Expr) IGameScoreDo
Omit(cols ...field.Expr) IGameScoreDo
Join(table schema.Tabler, on ...field.Expr) IGameScoreDo
LeftJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo
RightJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo
Group(cols ...field.Expr) IGameScoreDo
Having(conds ...gen.Condition) IGameScoreDo
Limit(limit int) IGameScoreDo
Offset(offset int) IGameScoreDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IGameScoreDo
Unscoped() IGameScoreDo
Create(values ...*model.GameScore) error
CreateInBatches(values []*model.GameScore, batchSize int) error
Save(values ...*model.GameScore) error
First() (*model.GameScore, error)
Take() (*model.GameScore, error)
Last() (*model.GameScore, error)
Find() ([]*model.GameScore, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.GameScore, err error)
FindInBatches(result *[]*model.GameScore, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.GameScore) (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) IGameScoreDo
Assign(attrs ...field.AssignExpr) IGameScoreDo
Joins(fields ...field.RelationField) IGameScoreDo
Preload(fields ...field.RelationField) IGameScoreDo
FirstOrInit() (*model.GameScore, error)
FirstOrCreate() (*model.GameScore, error)
FindByPage(offset int, limit int) (result []*model.GameScore, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IGameScoreDo
UnderlyingDB() *gorm.DB
schema.Tabler
GetUserRank(appId uint32, userId uint64, t uint32) (result querier.RankingData, err error)
FindDistinctRanking() (result []*model.GameScore, err error)
}
// SELECT
//
// app_user.nickname,
// app_user.avatar,
// gs.score,
// gs.app_user_id,
// gs.t_rank
// FROM
// (
// SELECT
// game_score.score,
// game_score.app_user_id,
// game_score.app_account,
// rank() OVER (ORDER BY game_score.score DESC) t_rank
// FROM
// game_score
// WHERE
// game_score.t = ?
// AND game_score.app_account = ?
// ) AS gs
// LEFT JOIN app_user ON app_user.id = gs.app_user_id
// WHERE
// gs.app_user_id = ?
// LIMIT 1;
func (g gameScoreDo) GetUserRank(appId uint32, userId uint64, t uint32) (result querier.RankingData, err error) {
var generateSQL strings.Builder
generateSQL.WriteString("SELECT app_user.nickname, app_user.avatar, gs.score, gs.app_user_id, gs.t_rank FROM ( SELECT game_score.score, game_score.app_user_id, game_score.app_account, rank() OVER (ORDER BY game_score.score DESC) t_rank FROM game_score WHERE game_score.t = ? AND game_score.app_account = ? ) AS gs LEFT JOIN app_user ON app_user.id = gs.app_user_id WHERE gs.app_user_id = ? LIMIT 1; ")
var executeSQL *gorm.DB
executeSQL = g.UnderlyingDB().Raw(generateSQL.String()).Take(&result) // ignore_security_alert
err = executeSQL.Error
return
}
// select DISTINCT app_account,t from game_score
func (g gameScoreDo) FindDistinctRanking() (result []*model.GameScore, err error) {
var generateSQL strings.Builder
generateSQL.WriteString("select DISTINCT app_account,t from game_score ")
var executeSQL *gorm.DB
executeSQL = g.UnderlyingDB().Raw(generateSQL.String()).Find(&result) // ignore_security_alert
err = executeSQL.Error
return
}
func (g gameScoreDo) Debug() IGameScoreDo {
return g.withDO(g.DO.Debug()) return g.withDO(g.DO.Debug())
} }
func (g gameScoreDo) WithContext(ctx context.Context) *gameScoreDo { func (g gameScoreDo) WithContext(ctx context.Context) IGameScoreDo {
return g.withDO(g.DO.WithContext(ctx)) return g.withDO(g.DO.WithContext(ctx))
} }
func (g gameScoreDo) ReadDB() *gameScoreDo { func (g gameScoreDo) ReadDB() IGameScoreDo {
return g.Clauses(dbresolver.Read) return g.Clauses(dbresolver.Read)
} }
func (g gameScoreDo) WriteDB() *gameScoreDo { func (g gameScoreDo) WriteDB() IGameScoreDo {
return g.Clauses(dbresolver.Write) return g.Clauses(dbresolver.Write)
} }
func (g gameScoreDo) Session(config *gorm.Session) *gameScoreDo { func (g gameScoreDo) Session(config *gorm.Session) IGameScoreDo {
return g.withDO(g.DO.Session(config)) return g.withDO(g.DO.Session(config))
} }
func (g gameScoreDo) Clauses(conds ...clause.Expression) *gameScoreDo { func (g gameScoreDo) Clauses(conds ...clause.Expression) IGameScoreDo {
return g.withDO(g.DO.Clauses(conds...)) return g.withDO(g.DO.Clauses(conds...))
} }
func (g gameScoreDo) Returning(value interface{}, columns ...string) *gameScoreDo { func (g gameScoreDo) Returning(value interface{}, columns ...string) IGameScoreDo {
return g.withDO(g.DO.Returning(value, columns...)) return g.withDO(g.DO.Returning(value, columns...))
} }
func (g gameScoreDo) Not(conds ...gen.Condition) *gameScoreDo { func (g gameScoreDo) Not(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Not(conds...)) return g.withDO(g.DO.Not(conds...))
} }
func (g gameScoreDo) Or(conds ...gen.Condition) *gameScoreDo { func (g gameScoreDo) Or(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Or(conds...)) return g.withDO(g.DO.Or(conds...))
} }
func (g gameScoreDo) Select(conds ...field.Expr) *gameScoreDo { func (g gameScoreDo) Select(conds ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Select(conds...)) return g.withDO(g.DO.Select(conds...))
} }
func (g gameScoreDo) Where(conds ...gen.Condition) *gameScoreDo { func (g gameScoreDo) Where(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Where(conds...)) return g.withDO(g.DO.Where(conds...))
} }
func (g gameScoreDo) Order(conds ...field.Expr) *gameScoreDo { func (g gameScoreDo) Order(conds ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Order(conds...)) return g.withDO(g.DO.Order(conds...))
} }
func (g gameScoreDo) Distinct(cols ...field.Expr) *gameScoreDo { func (g gameScoreDo) Distinct(cols ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Distinct(cols...)) return g.withDO(g.DO.Distinct(cols...))
} }
func (g gameScoreDo) Omit(cols ...field.Expr) *gameScoreDo { func (g gameScoreDo) Omit(cols ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Omit(cols...)) return g.withDO(g.DO.Omit(cols...))
} }
func (g gameScoreDo) Join(table schema.Tabler, on ...field.Expr) *gameScoreDo { func (g gameScoreDo) Join(table schema.Tabler, on ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Join(table, on...)) return g.withDO(g.DO.Join(table, on...))
} }
func (g gameScoreDo) LeftJoin(table schema.Tabler, on ...field.Expr) *gameScoreDo { func (g gameScoreDo) LeftJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.LeftJoin(table, on...)) return g.withDO(g.DO.LeftJoin(table, on...))
} }
func (g gameScoreDo) RightJoin(table schema.Tabler, on ...field.Expr) *gameScoreDo { func (g gameScoreDo) RightJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.RightJoin(table, on...)) return g.withDO(g.DO.RightJoin(table, on...))
} }
func (g gameScoreDo) Group(cols ...field.Expr) *gameScoreDo { func (g gameScoreDo) Group(cols ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Group(cols...)) return g.withDO(g.DO.Group(cols...))
} }
func (g gameScoreDo) Having(conds ...gen.Condition) *gameScoreDo { func (g gameScoreDo) Having(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Having(conds...)) return g.withDO(g.DO.Having(conds...))
} }
func (g gameScoreDo) Limit(limit int) *gameScoreDo { func (g gameScoreDo) Limit(limit int) IGameScoreDo {
return g.withDO(g.DO.Limit(limit)) return g.withDO(g.DO.Limit(limit))
} }
func (g gameScoreDo) Offset(offset int) *gameScoreDo { func (g gameScoreDo) Offset(offset int) IGameScoreDo {
return g.withDO(g.DO.Offset(offset)) return g.withDO(g.DO.Offset(offset))
} }
func (g gameScoreDo) Scopes(funcs ...func(gen.Dao) gen.Dao) *gameScoreDo { func (g gameScoreDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IGameScoreDo {
return g.withDO(g.DO.Scopes(funcs...)) return g.withDO(g.DO.Scopes(funcs...))
} }
func (g gameScoreDo) Unscoped() *gameScoreDo { func (g gameScoreDo) Unscoped() IGameScoreDo {
return g.withDO(g.DO.Unscoped()) return g.withDO(g.DO.Unscoped())
} }
@ -268,22 +375,22 @@ func (g gameScoreDo) FindInBatches(result *[]*model.GameScore, batchSize int, fc
return g.DO.FindInBatches(result, batchSize, fc) return g.DO.FindInBatches(result, batchSize, fc)
} }
func (g gameScoreDo) Attrs(attrs ...field.AssignExpr) *gameScoreDo { func (g gameScoreDo) Attrs(attrs ...field.AssignExpr) IGameScoreDo {
return g.withDO(g.DO.Attrs(attrs...)) return g.withDO(g.DO.Attrs(attrs...))
} }
func (g gameScoreDo) Assign(attrs ...field.AssignExpr) *gameScoreDo { func (g gameScoreDo) Assign(attrs ...field.AssignExpr) IGameScoreDo {
return g.withDO(g.DO.Assign(attrs...)) return g.withDO(g.DO.Assign(attrs...))
} }
func (g gameScoreDo) Joins(fields ...field.RelationField) *gameScoreDo { func (g gameScoreDo) Joins(fields ...field.RelationField) IGameScoreDo {
for _, _f := range fields { for _, _f := range fields {
g = *g.withDO(g.DO.Joins(_f)) g = *g.withDO(g.DO.Joins(_f))
} }
return &g return &g
} }
func (g gameScoreDo) Preload(fields ...field.RelationField) *gameScoreDo { func (g gameScoreDo) Preload(fields ...field.RelationField) IGameScoreDo {
for _, _f := range fields { for _, _f := range fields {
g = *g.withDO(g.DO.Preload(_f)) g = *g.withDO(g.DO.Preload(_f))
} }

24
gorm-gen/dao/query/gen.go
View File

@ -15,6 +15,22 @@ import (
"gorm.io/plugin/dbresolver" "gorm.io/plugin/dbresolver"
) )
var (
Q = new(Query)
AppAccount *appAccount
AppUser *appUser
DouyinEcpmConfig *douyinEcpmConfig
GameScore *gameScore
)
func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
*Q = *Use(db, opts...)
AppAccount = &Q.AppAccount
AppUser = &Q.AppUser
DouyinEcpmConfig = &Q.DouyinEcpmConfig
GameScore = &Q.GameScore
}
func Use(db *gorm.DB, opts ...gen.DOOption) *Query { func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
return &Query{ return &Query{
db: db, db: db,
@ -65,10 +81,10 @@ func (q *Query) ReplaceDB(db *gorm.DB) *Query {
} }
type queryCtx struct { type queryCtx struct {
AppAccount *appAccountDo AppAccount IAppAccountDo
AppUser *appUserDo AppUser IAppUserDo
DouyinEcpmConfig *douyinEcpmConfigDo DouyinEcpmConfig IDouyinEcpmConfigDo
GameScore *gameScoreDo GameScore IGameScoreDo
} }
func (q *Query) WithContext(ctx context.Context) *queryCtx { func (q *Query) WithContext(ctx context.Context) *queryCtx {

2
gorm-gen/gen_model.go
View File

@ -39,7 +39,7 @@ func GetRandomUsername() string {
func main() { func main() {
g := gen.NewGenerator(gen.Config{ g := gen.NewGenerator(gen.Config{
OutPath: "./query", OutPath: "./dao/query",
Mode: gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode Mode: gen.WithoutContext | gen.WithDefaultQuery | gen.WithQueryInterface, // generate mode
}) })
dsn := "root:youtu!0113@tcp(localhost:3306)/ecpm?charset=utf8&parseTime=True&loc=Local" dsn := "root:youtu!0113@tcp(localhost:3306)/ecpm?charset=utf8&parseTime=True&loc=Local"

417
gorm-gen/query/app_account.gen.go
View File

@ -1,417 +0,0 @@
// 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"
"strings"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model"
)
func newAppAccount(db *gorm.DB, opts ...gen.DOOption) appAccount {
_appAccount := appAccount{}
_appAccount.appAccountDo.UseDB(db, opts...)
_appAccount.appAccountDo.UseModel(&model.AppAccount{})
tableName := _appAccount.appAccountDo.TableName()
_appAccount.ALL = field.NewAsterisk(tableName)
_appAccount.ID = field.NewUint32(tableName, "id")
_appAccount.Type = field.NewUint32(tableName, "type")
_appAccount.AppID = field.NewString(tableName, "app_id")
_appAccount.Secret = field.NewString(tableName, "secret")
_appAccount.Remark = field.NewString(tableName, "remark")
_appAccount.DeletedAt = field.NewField(tableName, "deleted_at")
_appAccount.fillFieldMap()
return _appAccount
}
type appAccount struct {
appAccountDo
ALL field.Asterisk
ID field.Uint32
Type field.Uint32
AppID field.String
Secret field.String
Remark field.String
DeletedAt field.Field
fieldMap map[string]field.Expr
}
func (a appAccount) Table(newTableName string) *appAccount {
a.appAccountDo.UseTable(newTableName)
return a.updateTableName(newTableName)
}
func (a appAccount) As(alias string) *appAccount {
a.appAccountDo.DO = *(a.appAccountDo.As(alias).(*gen.DO))
return a.updateTableName(alias)
}
func (a *appAccount) updateTableName(table string) *appAccount {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewUint32(table, "id")
a.Type = field.NewUint32(table, "type")
a.AppID = field.NewString(table, "app_id")
a.Secret = field.NewString(table, "secret")
a.Remark = field.NewString(table, "remark")
a.DeletedAt = field.NewField(table, "deleted_at")
a.fillFieldMap()
return a
}
func (a *appAccount) 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 *appAccount) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 6)
a.fieldMap["id"] = a.ID
a.fieldMap["type"] = a.Type
a.fieldMap["app_id"] = a.AppID
a.fieldMap["secret"] = a.Secret
a.fieldMap["remark"] = a.Remark
a.fieldMap["deleted_at"] = a.DeletedAt
}
func (a appAccount) clone(db *gorm.DB) appAccount {
a.appAccountDo.ReplaceConnPool(db.Statement.ConnPool)
return a
}
func (a appAccount) replaceDB(db *gorm.DB) appAccount {
a.appAccountDo.ReplaceDB(db)
return a
}
type appAccountDo struct{ gen.DO }
type IAppAccountDo interface {
gen.SubQuery
Debug() IAppAccountDo
WithContext(ctx context.Context) IAppAccountDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IAppAccountDo
WriteDB() IAppAccountDo
As(alias string) gen.Dao
Session(config *gorm.Session) IAppAccountDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IAppAccountDo
Not(conds ...gen.Condition) IAppAccountDo
Or(conds ...gen.Condition) IAppAccountDo
Select(conds ...field.Expr) IAppAccountDo
Where(conds ...gen.Condition) IAppAccountDo
Order(conds ...field.Expr) IAppAccountDo
Distinct(cols ...field.Expr) IAppAccountDo
Omit(cols ...field.Expr) IAppAccountDo
Join(table schema.Tabler, on ...field.Expr) IAppAccountDo
LeftJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo
RightJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo
Group(cols ...field.Expr) IAppAccountDo
Having(conds ...gen.Condition) IAppAccountDo
Limit(limit int) IAppAccountDo
Offset(offset int) IAppAccountDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IAppAccountDo
Unscoped() IAppAccountDo
Create(values ...*model.AppAccount) error
CreateInBatches(values []*model.AppAccount, batchSize int) error
Save(values ...*model.AppAccount) error
First() (*model.AppAccount, error)
Take() (*model.AppAccount, error)
Last() (*model.AppAccount, error)
Find() ([]*model.AppAccount, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppAccount, err error)
FindInBatches(result *[]*model.AppAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.AppAccount) (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) IAppAccountDo
Assign(attrs ...field.AssignExpr) IAppAccountDo
Joins(fields ...field.RelationField) IAppAccountDo
Preload(fields ...field.RelationField) IAppAccountDo
FirstOrInit() (*model.AppAccount, error)
FirstOrCreate() (*model.AppAccount, error)
FindByPage(offset int, limit int) (result []*model.AppAccount, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IAppAccountDo
UnderlyingDB() *gorm.DB
schema.Tabler
GetAppConfig() (result []*model.AppAccount, err error)
}
// GetAppConfig 获取所有小游戏配置
//
// select `app_id`,`secret`,`ecpm_value`,`ecpm_view`,`type` from `app_account` left join douyin_ecpm_config on app_account.id = douyin_ecpm_config.app_account_id
func (a appAccountDo) GetAppConfig() (result []*model.AppAccount, err error) {
var generateSQL strings.Builder
generateSQL.WriteString("select `app_id`,`secret`,`ecpm_value`,`ecpm_view`,`type` from `app_account` left join douyin_ecpm_config on app_account.id = douyin_ecpm_config.app_account_id ")
var executeSQL *gorm.DB
executeSQL = a.UnderlyingDB().Raw(generateSQL.String()).Find(&result) // ignore_security_alert
err = executeSQL.Error
return
}
func (a appAccountDo) Debug() IAppAccountDo {
return a.withDO(a.DO.Debug())
}
func (a appAccountDo) WithContext(ctx context.Context) IAppAccountDo {
return a.withDO(a.DO.WithContext(ctx))
}
func (a appAccountDo) ReadDB() IAppAccountDo {
return a.Clauses(dbresolver.Read)
}
func (a appAccountDo) WriteDB() IAppAccountDo {
return a.Clauses(dbresolver.Write)
}
func (a appAccountDo) Session(config *gorm.Session) IAppAccountDo {
return a.withDO(a.DO.Session(config))
}
func (a appAccountDo) Clauses(conds ...clause.Expression) IAppAccountDo {
return a.withDO(a.DO.Clauses(conds...))
}
func (a appAccountDo) Returning(value interface{}, columns ...string) IAppAccountDo {
return a.withDO(a.DO.Returning(value, columns...))
}
func (a appAccountDo) Not(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Not(conds...))
}
func (a appAccountDo) Or(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Or(conds...))
}
func (a appAccountDo) Select(conds ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Select(conds...))
}
func (a appAccountDo) Where(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Where(conds...))
}
func (a appAccountDo) Order(conds ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Order(conds...))
}
func (a appAccountDo) Distinct(cols ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Distinct(cols...))
}
func (a appAccountDo) Omit(cols ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Omit(cols...))
}
func (a appAccountDo) Join(table schema.Tabler, on ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Join(table, on...))
}
func (a appAccountDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.LeftJoin(table, on...))
}
func (a appAccountDo) RightJoin(table schema.Tabler, on ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.RightJoin(table, on...))
}
func (a appAccountDo) Group(cols ...field.Expr) IAppAccountDo {
return a.withDO(a.DO.Group(cols...))
}
func (a appAccountDo) Having(conds ...gen.Condition) IAppAccountDo {
return a.withDO(a.DO.Having(conds...))
}
func (a appAccountDo) Limit(limit int) IAppAccountDo {
return a.withDO(a.DO.Limit(limit))
}
func (a appAccountDo) Offset(offset int) IAppAccountDo {
return a.withDO(a.DO.Offset(offset))
}
func (a appAccountDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAppAccountDo {
return a.withDO(a.DO.Scopes(funcs...))
}
func (a appAccountDo) Unscoped() IAppAccountDo {
return a.withDO(a.DO.Unscoped())
}
func (a appAccountDo) Create(values ...*model.AppAccount) error {
if len(values) == 0 {
return nil
}
return a.DO.Create(values)
}
func (a appAccountDo) CreateInBatches(values []*model.AppAccount, 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 appAccountDo) Save(values ...*model.AppAccount) error {
if len(values) == 0 {
return nil
}
return a.DO.Save(values)
}
func (a appAccountDo) First() (*model.AppAccount, error) {
if result, err := a.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.AppAccount), nil
}
}
func (a appAccountDo) Take() (*model.AppAccount, error) {
if result, err := a.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.AppAccount), nil
}
}
func (a appAccountDo) Last() (*model.AppAccount, error) {
if result, err := a.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.AppAccount), nil
}
}
func (a appAccountDo) Find() ([]*model.AppAccount, error) {
result, err := a.DO.Find()
return result.([]*model.AppAccount), err
}
func (a appAccountDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppAccount, err error) {
buf := make([]*model.AppAccount, 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 appAccountDo) FindInBatches(result *[]*model.AppAccount, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return a.DO.FindInBatches(result, batchSize, fc)
}
func (a appAccountDo) Attrs(attrs ...field.AssignExpr) IAppAccountDo {
return a.withDO(a.DO.Attrs(attrs...))
}
func (a appAccountDo) Assign(attrs ...field.AssignExpr) IAppAccountDo {
return a.withDO(a.DO.Assign(attrs...))
}
func (a appAccountDo) Joins(fields ...field.RelationField) IAppAccountDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Joins(_f))
}
return &a
}
func (a appAccountDo) Preload(fields ...field.RelationField) IAppAccountDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Preload(_f))
}
return &a
}
func (a appAccountDo) FirstOrInit() (*model.AppAccount, error) {
if result, err := a.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.AppAccount), nil
}
}
func (a appAccountDo) FirstOrCreate() (*model.AppAccount, error) {
if result, err := a.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.AppAccount), nil
}
}
func (a appAccountDo) FindByPage(offset int, limit int) (result []*model.AppAccount, 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 appAccountDo) 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 appAccountDo) Scan(result interface{}) (err error) {
return a.DO.Scan(result)
}
func (a appAccountDo) Delete(models ...*model.AppAccount) (result gen.ResultInfo, err error) {
return a.DO.Delete(models)
}
func (a *appAccountDo) withDO(do gen.Dao) *appAccountDo {
a.DO = *do.(*gen.DO)
return a
}

412
gorm-gen/query/app_user.gen.go
View File

@ -1,412 +0,0 @@
// 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"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model"
)
func newAppUser(db *gorm.DB, opts ...gen.DOOption) appUser {
_appUser := appUser{}
_appUser.appUserDo.UseDB(db, opts...)
_appUser.appUserDo.UseModel(&model.AppUser{})
tableName := _appUser.appUserDo.TableName()
_appUser.ALL = field.NewAsterisk(tableName)
_appUser.ID = field.NewUint64(tableName, "id")
_appUser.AppAccountID = field.NewUint32(tableName, "app_account_id")
_appUser.Openid = field.NewString(tableName, "openid")
_appUser.Unionid = field.NewString(tableName, "unionid")
_appUser.Nickname = field.NewString(tableName, "nickname")
_appUser.Avatar = field.NewString(tableName, "avatar")
_appUser.AnonymousOpenid = field.NewString(tableName, "anonymous_openid")
_appUser.CreatedAt = field.NewTime(tableName, "created_at")
_appUser.UpdatedAt = field.NewTime(tableName, "updated_at")
_appUser.fillFieldMap()
return _appUser
}
type appUser struct {
appUserDo
ALL field.Asterisk
ID field.Uint64
AppAccountID field.Uint32
Openid field.String
Unionid field.String
Nickname field.String
Avatar field.String
AnonymousOpenid field.String
CreatedAt field.Time
UpdatedAt field.Time
fieldMap map[string]field.Expr
}
func (a appUser) Table(newTableName string) *appUser {
a.appUserDo.UseTable(newTableName)
return a.updateTableName(newTableName)
}
func (a appUser) As(alias string) *appUser {
a.appUserDo.DO = *(a.appUserDo.As(alias).(*gen.DO))
return a.updateTableName(alias)
}
func (a *appUser) updateTableName(table string) *appUser {
a.ALL = field.NewAsterisk(table)
a.ID = field.NewUint64(table, "id")
a.AppAccountID = field.NewUint32(table, "app_account_id")
a.Openid = field.NewString(table, "openid")
a.Unionid = field.NewString(table, "unionid")
a.Nickname = field.NewString(table, "nickname")
a.Avatar = field.NewString(table, "avatar")
a.AnonymousOpenid = field.NewString(table, "anonymous_openid")
a.CreatedAt = field.NewTime(table, "created_at")
a.UpdatedAt = field.NewTime(table, "updated_at")
a.fillFieldMap()
return a
}
func (a *appUser) 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 *appUser) fillFieldMap() {
a.fieldMap = make(map[string]field.Expr, 9)
a.fieldMap["id"] = a.ID
a.fieldMap["app_account_id"] = a.AppAccountID
a.fieldMap["openid"] = a.Openid
a.fieldMap["unionid"] = a.Unionid
a.fieldMap["nickname"] = a.Nickname
a.fieldMap["avatar"] = a.Avatar
a.fieldMap["anonymous_openid"] = a.AnonymousOpenid
a.fieldMap["created_at"] = a.CreatedAt
a.fieldMap["updated_at"] = a.UpdatedAt
}
func (a appUser) clone(db *gorm.DB) appUser {
a.appUserDo.ReplaceConnPool(db.Statement.ConnPool)
return a
}
func (a appUser) replaceDB(db *gorm.DB) appUser {
a.appUserDo.ReplaceDB(db)
return a
}
type appUserDo struct{ gen.DO }
type IAppUserDo interface {
gen.SubQuery
Debug() IAppUserDo
WithContext(ctx context.Context) IAppUserDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IAppUserDo
WriteDB() IAppUserDo
As(alias string) gen.Dao
Session(config *gorm.Session) IAppUserDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IAppUserDo
Not(conds ...gen.Condition) IAppUserDo
Or(conds ...gen.Condition) IAppUserDo
Select(conds ...field.Expr) IAppUserDo
Where(conds ...gen.Condition) IAppUserDo
Order(conds ...field.Expr) IAppUserDo
Distinct(cols ...field.Expr) IAppUserDo
Omit(cols ...field.Expr) IAppUserDo
Join(table schema.Tabler, on ...field.Expr) IAppUserDo
LeftJoin(table schema.Tabler, on ...field.Expr) IAppUserDo
RightJoin(table schema.Tabler, on ...field.Expr) IAppUserDo
Group(cols ...field.Expr) IAppUserDo
Having(conds ...gen.Condition) IAppUserDo
Limit(limit int) IAppUserDo
Offset(offset int) IAppUserDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IAppUserDo
Unscoped() IAppUserDo
Create(values ...*model.AppUser) error
CreateInBatches(values []*model.AppUser, batchSize int) error
Save(values ...*model.AppUser) error
First() (*model.AppUser, error)
Take() (*model.AppUser, error)
Last() (*model.AppUser, error)
Find() ([]*model.AppUser, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppUser, err error)
FindInBatches(result *[]*model.AppUser, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.AppUser) (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) IAppUserDo
Assign(attrs ...field.AssignExpr) IAppUserDo
Joins(fields ...field.RelationField) IAppUserDo
Preload(fields ...field.RelationField) IAppUserDo
FirstOrInit() (*model.AppUser, error)
FirstOrCreate() (*model.AppUser, error)
FindByPage(offset int, limit int) (result []*model.AppUser, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IAppUserDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (a appUserDo) Debug() IAppUserDo {
return a.withDO(a.DO.Debug())
}
func (a appUserDo) WithContext(ctx context.Context) IAppUserDo {
return a.withDO(a.DO.WithContext(ctx))
}
func (a appUserDo) ReadDB() IAppUserDo {
return a.Clauses(dbresolver.Read)
}
func (a appUserDo) WriteDB() IAppUserDo {
return a.Clauses(dbresolver.Write)
}
func (a appUserDo) Session(config *gorm.Session) IAppUserDo {
return a.withDO(a.DO.Session(config))
}
func (a appUserDo) Clauses(conds ...clause.Expression) IAppUserDo {
return a.withDO(a.DO.Clauses(conds...))
}
func (a appUserDo) Returning(value interface{}, columns ...string) IAppUserDo {
return a.withDO(a.DO.Returning(value, columns...))
}
func (a appUserDo) Not(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Not(conds...))
}
func (a appUserDo) Or(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Or(conds...))
}
func (a appUserDo) Select(conds ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Select(conds...))
}
func (a appUserDo) Where(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Where(conds...))
}
func (a appUserDo) Order(conds ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Order(conds...))
}
func (a appUserDo) Distinct(cols ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Distinct(cols...))
}
func (a appUserDo) Omit(cols ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Omit(cols...))
}
func (a appUserDo) Join(table schema.Tabler, on ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Join(table, on...))
}
func (a appUserDo) LeftJoin(table schema.Tabler, on ...field.Expr) IAppUserDo {
return a.withDO(a.DO.LeftJoin(table, on...))
}
func (a appUserDo) RightJoin(table schema.Tabler, on ...field.Expr) IAppUserDo {
return a.withDO(a.DO.RightJoin(table, on...))
}
func (a appUserDo) Group(cols ...field.Expr) IAppUserDo {
return a.withDO(a.DO.Group(cols...))
}
func (a appUserDo) Having(conds ...gen.Condition) IAppUserDo {
return a.withDO(a.DO.Having(conds...))
}
func (a appUserDo) Limit(limit int) IAppUserDo {
return a.withDO(a.DO.Limit(limit))
}
func (a appUserDo) Offset(offset int) IAppUserDo {
return a.withDO(a.DO.Offset(offset))
}
func (a appUserDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IAppUserDo {
return a.withDO(a.DO.Scopes(funcs...))
}
func (a appUserDo) Unscoped() IAppUserDo {
return a.withDO(a.DO.Unscoped())
}
func (a appUserDo) Create(values ...*model.AppUser) error {
if len(values) == 0 {
return nil
}
return a.DO.Create(values)
}
func (a appUserDo) CreateInBatches(values []*model.AppUser, 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 appUserDo) Save(values ...*model.AppUser) error {
if len(values) == 0 {
return nil
}
return a.DO.Save(values)
}
func (a appUserDo) First() (*model.AppUser, error) {
if result, err := a.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.AppUser), nil
}
}
func (a appUserDo) Take() (*model.AppUser, error) {
if result, err := a.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.AppUser), nil
}
}
func (a appUserDo) Last() (*model.AppUser, error) {
if result, err := a.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.AppUser), nil
}
}
func (a appUserDo) Find() ([]*model.AppUser, error) {
result, err := a.DO.Find()
return result.([]*model.AppUser), err
}
func (a appUserDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.AppUser, err error) {
buf := make([]*model.AppUser, 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 appUserDo) FindInBatches(result *[]*model.AppUser, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return a.DO.FindInBatches(result, batchSize, fc)
}
func (a appUserDo) Attrs(attrs ...field.AssignExpr) IAppUserDo {
return a.withDO(a.DO.Attrs(attrs...))
}
func (a appUserDo) Assign(attrs ...field.AssignExpr) IAppUserDo {
return a.withDO(a.DO.Assign(attrs...))
}
func (a appUserDo) Joins(fields ...field.RelationField) IAppUserDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Joins(_f))
}
return &a
}
func (a appUserDo) Preload(fields ...field.RelationField) IAppUserDo {
for _, _f := range fields {
a = *a.withDO(a.DO.Preload(_f))
}
return &a
}
func (a appUserDo) FirstOrInit() (*model.AppUser, error) {
if result, err := a.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.AppUser), nil
}
}
func (a appUserDo) FirstOrCreate() (*model.AppUser, error) {
if result, err := a.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.AppUser), nil
}
}
func (a appUserDo) FindByPage(offset int, limit int) (result []*model.AppUser, 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 appUserDo) 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 appUserDo) Scan(result interface{}) (err error) {
return a.DO.Scan(result)
}
func (a appUserDo) Delete(models ...*model.AppUser) (result gen.ResultInfo, err error) {
return a.DO.Delete(models)
}
func (a *appUserDo) withDO(do gen.Dao) *appUserDo {
a.DO = *do.(*gen.DO)
return a
}

392
gorm-gen/query/douyin_ecpm_config.gen.go
View File

@ -1,392 +0,0 @@
// 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"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model"
)
func newDouyinEcpmConfig(db *gorm.DB, opts ...gen.DOOption) douyinEcpmConfig {
_douyinEcpmConfig := douyinEcpmConfig{}
_douyinEcpmConfig.douyinEcpmConfigDo.UseDB(db, opts...)
_douyinEcpmConfig.douyinEcpmConfigDo.UseModel(&model.DouyinEcpmConfig{})
tableName := _douyinEcpmConfig.douyinEcpmConfigDo.TableName()
_douyinEcpmConfig.ALL = field.NewAsterisk(tableName)
_douyinEcpmConfig.ID = field.NewUint32(tableName, "id")
_douyinEcpmConfig.AppAccountID = field.NewUint32(tableName, "app_account_id")
_douyinEcpmConfig.EcpmValue = field.NewUint32(tableName, "ecpm_value")
_douyinEcpmConfig.EcpmView = field.NewUint32(tableName, "ecpm_view")
_douyinEcpmConfig.fillFieldMap()
return _douyinEcpmConfig
}
type douyinEcpmConfig struct {
douyinEcpmConfigDo
ALL field.Asterisk
ID field.Uint32
AppAccountID field.Uint32
EcpmValue field.Uint32
EcpmView field.Uint32
fieldMap map[string]field.Expr
}
func (d douyinEcpmConfig) Table(newTableName string) *douyinEcpmConfig {
d.douyinEcpmConfigDo.UseTable(newTableName)
return d.updateTableName(newTableName)
}
func (d douyinEcpmConfig) As(alias string) *douyinEcpmConfig {
d.douyinEcpmConfigDo.DO = *(d.douyinEcpmConfigDo.As(alias).(*gen.DO))
return d.updateTableName(alias)
}
func (d *douyinEcpmConfig) updateTableName(table string) *douyinEcpmConfig {
d.ALL = field.NewAsterisk(table)
d.ID = field.NewUint32(table, "id")
d.AppAccountID = field.NewUint32(table, "app_account_id")
d.EcpmValue = field.NewUint32(table, "ecpm_value")
d.EcpmView = field.NewUint32(table, "ecpm_view")
d.fillFieldMap()
return d
}
func (d *douyinEcpmConfig) 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 *douyinEcpmConfig) fillFieldMap() {
d.fieldMap = make(map[string]field.Expr, 4)
d.fieldMap["id"] = d.ID
d.fieldMap["app_account_id"] = d.AppAccountID
d.fieldMap["ecpm_value"] = d.EcpmValue
d.fieldMap["ecpm_view"] = d.EcpmView
}
func (d douyinEcpmConfig) clone(db *gorm.DB) douyinEcpmConfig {
d.douyinEcpmConfigDo.ReplaceConnPool(db.Statement.ConnPool)
return d
}
func (d douyinEcpmConfig) replaceDB(db *gorm.DB) douyinEcpmConfig {
d.douyinEcpmConfigDo.ReplaceDB(db)
return d
}
type douyinEcpmConfigDo struct{ gen.DO }
type IDouyinEcpmConfigDo interface {
gen.SubQuery
Debug() IDouyinEcpmConfigDo
WithContext(ctx context.Context) IDouyinEcpmConfigDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IDouyinEcpmConfigDo
WriteDB() IDouyinEcpmConfigDo
As(alias string) gen.Dao
Session(config *gorm.Session) IDouyinEcpmConfigDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IDouyinEcpmConfigDo
Not(conds ...gen.Condition) IDouyinEcpmConfigDo
Or(conds ...gen.Condition) IDouyinEcpmConfigDo
Select(conds ...field.Expr) IDouyinEcpmConfigDo
Where(conds ...gen.Condition) IDouyinEcpmConfigDo
Order(conds ...field.Expr) IDouyinEcpmConfigDo
Distinct(cols ...field.Expr) IDouyinEcpmConfigDo
Omit(cols ...field.Expr) IDouyinEcpmConfigDo
Join(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo
LeftJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo
RightJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo
Group(cols ...field.Expr) IDouyinEcpmConfigDo
Having(conds ...gen.Condition) IDouyinEcpmConfigDo
Limit(limit int) IDouyinEcpmConfigDo
Offset(offset int) IDouyinEcpmConfigDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IDouyinEcpmConfigDo
Unscoped() IDouyinEcpmConfigDo
Create(values ...*model.DouyinEcpmConfig) error
CreateInBatches(values []*model.DouyinEcpmConfig, batchSize int) error
Save(values ...*model.DouyinEcpmConfig) error
First() (*model.DouyinEcpmConfig, error)
Take() (*model.DouyinEcpmConfig, error)
Last() (*model.DouyinEcpmConfig, error)
Find() ([]*model.DouyinEcpmConfig, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DouyinEcpmConfig, err error)
FindInBatches(result *[]*model.DouyinEcpmConfig, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.DouyinEcpmConfig) (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) IDouyinEcpmConfigDo
Assign(attrs ...field.AssignExpr) IDouyinEcpmConfigDo
Joins(fields ...field.RelationField) IDouyinEcpmConfigDo
Preload(fields ...field.RelationField) IDouyinEcpmConfigDo
FirstOrInit() (*model.DouyinEcpmConfig, error)
FirstOrCreate() (*model.DouyinEcpmConfig, error)
FindByPage(offset int, limit int) (result []*model.DouyinEcpmConfig, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IDouyinEcpmConfigDo
UnderlyingDB() *gorm.DB
schema.Tabler
}
func (d douyinEcpmConfigDo) Debug() IDouyinEcpmConfigDo {
return d.withDO(d.DO.Debug())
}
func (d douyinEcpmConfigDo) WithContext(ctx context.Context) IDouyinEcpmConfigDo {
return d.withDO(d.DO.WithContext(ctx))
}
func (d douyinEcpmConfigDo) ReadDB() IDouyinEcpmConfigDo {
return d.Clauses(dbresolver.Read)
}
func (d douyinEcpmConfigDo) WriteDB() IDouyinEcpmConfigDo {
return d.Clauses(dbresolver.Write)
}
func (d douyinEcpmConfigDo) Session(config *gorm.Session) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Session(config))
}
func (d douyinEcpmConfigDo) Clauses(conds ...clause.Expression) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Clauses(conds...))
}
func (d douyinEcpmConfigDo) Returning(value interface{}, columns ...string) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Returning(value, columns...))
}
func (d douyinEcpmConfigDo) Not(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Not(conds...))
}
func (d douyinEcpmConfigDo) Or(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Or(conds...))
}
func (d douyinEcpmConfigDo) Select(conds ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Select(conds...))
}
func (d douyinEcpmConfigDo) Where(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Where(conds...))
}
func (d douyinEcpmConfigDo) Order(conds ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Order(conds...))
}
func (d douyinEcpmConfigDo) Distinct(cols ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Distinct(cols...))
}
func (d douyinEcpmConfigDo) Omit(cols ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Omit(cols...))
}
func (d douyinEcpmConfigDo) Join(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Join(table, on...))
}
func (d douyinEcpmConfigDo) LeftJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.LeftJoin(table, on...))
}
func (d douyinEcpmConfigDo) RightJoin(table schema.Tabler, on ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.RightJoin(table, on...))
}
func (d douyinEcpmConfigDo) Group(cols ...field.Expr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Group(cols...))
}
func (d douyinEcpmConfigDo) Having(conds ...gen.Condition) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Having(conds...))
}
func (d douyinEcpmConfigDo) Limit(limit int) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Limit(limit))
}
func (d douyinEcpmConfigDo) Offset(offset int) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Offset(offset))
}
func (d douyinEcpmConfigDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Scopes(funcs...))
}
func (d douyinEcpmConfigDo) Unscoped() IDouyinEcpmConfigDo {
return d.withDO(d.DO.Unscoped())
}
func (d douyinEcpmConfigDo) Create(values ...*model.DouyinEcpmConfig) error {
if len(values) == 0 {
return nil
}
return d.DO.Create(values)
}
func (d douyinEcpmConfigDo) CreateInBatches(values []*model.DouyinEcpmConfig, 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 douyinEcpmConfigDo) Save(values ...*model.DouyinEcpmConfig) error {
if len(values) == 0 {
return nil
}
return d.DO.Save(values)
}
func (d douyinEcpmConfigDo) First() (*model.DouyinEcpmConfig, error) {
if result, err := d.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.DouyinEcpmConfig), nil
}
}
func (d douyinEcpmConfigDo) Take() (*model.DouyinEcpmConfig, error) {
if result, err := d.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.DouyinEcpmConfig), nil
}
}
func (d douyinEcpmConfigDo) Last() (*model.DouyinEcpmConfig, error) {
if result, err := d.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.DouyinEcpmConfig), nil
}
}
func (d douyinEcpmConfigDo) Find() ([]*model.DouyinEcpmConfig, error) {
result, err := d.DO.Find()
return result.([]*model.DouyinEcpmConfig), err
}
func (d douyinEcpmConfigDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.DouyinEcpmConfig, err error) {
buf := make([]*model.DouyinEcpmConfig, 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 douyinEcpmConfigDo) FindInBatches(result *[]*model.DouyinEcpmConfig, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return d.DO.FindInBatches(result, batchSize, fc)
}
func (d douyinEcpmConfigDo) Attrs(attrs ...field.AssignExpr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Attrs(attrs...))
}
func (d douyinEcpmConfigDo) Assign(attrs ...field.AssignExpr) IDouyinEcpmConfigDo {
return d.withDO(d.DO.Assign(attrs...))
}
func (d douyinEcpmConfigDo) Joins(fields ...field.RelationField) IDouyinEcpmConfigDo {
for _, _f := range fields {
d = *d.withDO(d.DO.Joins(_f))
}
return &d
}
func (d douyinEcpmConfigDo) Preload(fields ...field.RelationField) IDouyinEcpmConfigDo {
for _, _f := range fields {
d = *d.withDO(d.DO.Preload(_f))
}
return &d
}
func (d douyinEcpmConfigDo) FirstOrInit() (*model.DouyinEcpmConfig, error) {
if result, err := d.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.DouyinEcpmConfig), nil
}
}
func (d douyinEcpmConfigDo) FirstOrCreate() (*model.DouyinEcpmConfig, error) {
if result, err := d.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.DouyinEcpmConfig), nil
}
}
func (d douyinEcpmConfigDo) FindByPage(offset int, limit int) (result []*model.DouyinEcpmConfig, 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 douyinEcpmConfigDo) 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 douyinEcpmConfigDo) Scan(result interface{}) (err error) {
return d.DO.Scan(result)
}
func (d douyinEcpmConfigDo) Delete(models ...*model.DouyinEcpmConfig) (result gen.ResultInfo, err error) {
return d.DO.Delete(models)
}
func (d *douyinEcpmConfigDo) withDO(do gen.Dao) *douyinEcpmConfigDo {
d.DO = *do.(*gen.DO)
return d
}

448
gorm-gen/query/game_score.gen.go
View File

@ -1,448 +0,0 @@
// 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"
"strings"
"gorm.io/gorm"
"gorm.io/gorm/clause"
"gorm.io/gorm/schema"
"gorm.io/gen"
"gorm.io/gen/field"
"gorm.io/plugin/dbresolver"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/dao/model"
"gitea.youtukeji.com.cn/xiabin/youtu_server/gorm-gen/querier"
)
func newGameScore(db *gorm.DB, opts ...gen.DOOption) gameScore {
_gameScore := gameScore{}
_gameScore.gameScoreDo.UseDB(db, opts...)
_gameScore.gameScoreDo.UseModel(&model.GameScore{})
tableName := _gameScore.gameScoreDo.TableName()
_gameScore.ALL = field.NewAsterisk(tableName)
_gameScore.ID = field.NewUint64(tableName, "id")
_gameScore.AppAccount = field.NewUint32(tableName, "app_account")
_gameScore.AppUserID = field.NewUint64(tableName, "app_user_id")
_gameScore.Score = field.NewUint32(tableName, "score")
_gameScore.T = field.NewUint32(tableName, "t")
_gameScore.fillFieldMap()
return _gameScore
}
type gameScore struct {
gameScoreDo
ALL field.Asterisk
ID field.Uint64
AppAccount field.Uint32
AppUserID field.Uint64
Score field.Uint32
T field.Uint32
fieldMap map[string]field.Expr
}
func (g gameScore) Table(newTableName string) *gameScore {
g.gameScoreDo.UseTable(newTableName)
return g.updateTableName(newTableName)
}
func (g gameScore) As(alias string) *gameScore {
g.gameScoreDo.DO = *(g.gameScoreDo.As(alias).(*gen.DO))
return g.updateTableName(alias)
}
func (g *gameScore) updateTableName(table string) *gameScore {
g.ALL = field.NewAsterisk(table)
g.ID = field.NewUint64(table, "id")
g.AppAccount = field.NewUint32(table, "app_account")
g.AppUserID = field.NewUint64(table, "app_user_id")
g.Score = field.NewUint32(table, "score")
g.T = field.NewUint32(table, "t")
g.fillFieldMap()
return g
}
func (g *gameScore) GetFieldByName(fieldName string) (field.OrderExpr, bool) {
_f, ok := g.fieldMap[fieldName]
if !ok || _f == nil {
return nil, false
}
_oe, ok := _f.(field.OrderExpr)
return _oe, ok
}
func (g *gameScore) fillFieldMap() {
g.fieldMap = make(map[string]field.Expr, 5)
g.fieldMap["id"] = g.ID
g.fieldMap["app_account"] = g.AppAccount
g.fieldMap["app_user_id"] = g.AppUserID
g.fieldMap["score"] = g.Score
g.fieldMap["t"] = g.T
}
func (g gameScore) clone(db *gorm.DB) gameScore {
g.gameScoreDo.ReplaceConnPool(db.Statement.ConnPool)
return g
}
func (g gameScore) replaceDB(db *gorm.DB) gameScore {
g.gameScoreDo.ReplaceDB(db)
return g
}
type gameScoreDo struct{ gen.DO }
type IGameScoreDo interface {
gen.SubQuery
Debug() IGameScoreDo
WithContext(ctx context.Context) IGameScoreDo
WithResult(fc func(tx gen.Dao)) gen.ResultInfo
ReplaceDB(db *gorm.DB)
ReadDB() IGameScoreDo
WriteDB() IGameScoreDo
As(alias string) gen.Dao
Session(config *gorm.Session) IGameScoreDo
Columns(cols ...field.Expr) gen.Columns
Clauses(conds ...clause.Expression) IGameScoreDo
Not(conds ...gen.Condition) IGameScoreDo
Or(conds ...gen.Condition) IGameScoreDo
Select(conds ...field.Expr) IGameScoreDo
Where(conds ...gen.Condition) IGameScoreDo
Order(conds ...field.Expr) IGameScoreDo
Distinct(cols ...field.Expr) IGameScoreDo
Omit(cols ...field.Expr) IGameScoreDo
Join(table schema.Tabler, on ...field.Expr) IGameScoreDo
LeftJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo
RightJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo
Group(cols ...field.Expr) IGameScoreDo
Having(conds ...gen.Condition) IGameScoreDo
Limit(limit int) IGameScoreDo
Offset(offset int) IGameScoreDo
Count() (count int64, err error)
Scopes(funcs ...func(gen.Dao) gen.Dao) IGameScoreDo
Unscoped() IGameScoreDo
Create(values ...*model.GameScore) error
CreateInBatches(values []*model.GameScore, batchSize int) error
Save(values ...*model.GameScore) error
First() (*model.GameScore, error)
Take() (*model.GameScore, error)
Last() (*model.GameScore, error)
Find() ([]*model.GameScore, error)
FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.GameScore, err error)
FindInBatches(result *[]*model.GameScore, batchSize int, fc func(tx gen.Dao, batch int) error) error
Pluck(column field.Expr, dest interface{}) error
Delete(...*model.GameScore) (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) IGameScoreDo
Assign(attrs ...field.AssignExpr) IGameScoreDo
Joins(fields ...field.RelationField) IGameScoreDo
Preload(fields ...field.RelationField) IGameScoreDo
FirstOrInit() (*model.GameScore, error)
FirstOrCreate() (*model.GameScore, error)
FindByPage(offset int, limit int) (result []*model.GameScore, count int64, err error)
ScanByPage(result interface{}, offset int, limit int) (count int64, err error)
Scan(result interface{}) (err error)
Returning(value interface{}, columns ...string) IGameScoreDo
UnderlyingDB() *gorm.DB
schema.Tabler
GetUserRank(appId uint32, userId uint64, t uint32) (result querier.RankingData, err error)
FindDistinctRanking() (result []*model.GameScore, err error)
}
// SELECT
//
// app_user.nickname,
// app_user.avatar,
// gs.score,
// gs.app_user_id,
// gs.t_rank
// FROM
// (
// SELECT
// game_score.score,
// game_score.app_user_id,
// game_score.app_account,
// rank() OVER (ORDER BY game_score.score DESC) t_rank
// FROM
// game_score
// WHERE
// game_score.t = ?
// AND game_score.app_account = ?
// ) AS gs
// LEFT JOIN app_user ON app_user.id = gs.app_user_id
// WHERE
// gs.app_user_id = ?
// LIMIT 1;
func (g gameScoreDo) GetUserRank(appId uint32, userId uint64, t uint32) (result querier.RankingData, err error) {
var generateSQL strings.Builder
generateSQL.WriteString("SELECT app_user.nickname, app_user.avatar, gs.score, gs.app_user_id, gs.t_rank FROM ( SELECT game_score.score, game_score.app_user_id, game_score.app_account, rank() OVER (ORDER BY game_score.score DESC) t_rank FROM game_score WHERE game_score.t = ? AND game_score.app_account = ? ) AS gs LEFT JOIN app_user ON app_user.id = gs.app_user_id WHERE gs.app_user_id = ? LIMIT 1; ")
var executeSQL *gorm.DB
executeSQL = g.UnderlyingDB().Raw(generateSQL.String()).Take(&result) // ignore_security_alert
err = executeSQL.Error
return
}
// select DISTINCT app_account,t from game_score
func (g gameScoreDo) FindDistinctRanking() (result []*model.GameScore, err error) {
var generateSQL strings.Builder
generateSQL.WriteString("select DISTINCT app_account,t from game_score ")
var executeSQL *gorm.DB
executeSQL = g.UnderlyingDB().Raw(generateSQL.String()).Find(&result) // ignore_security_alert
err = executeSQL.Error
return
}
func (g gameScoreDo) Debug() IGameScoreDo {
return g.withDO(g.DO.Debug())
}
func (g gameScoreDo) WithContext(ctx context.Context) IGameScoreDo {
return g.withDO(g.DO.WithContext(ctx))
}
func (g gameScoreDo) ReadDB() IGameScoreDo {
return g.Clauses(dbresolver.Read)
}
func (g gameScoreDo) WriteDB() IGameScoreDo {
return g.Clauses(dbresolver.Write)
}
func (g gameScoreDo) Session(config *gorm.Session) IGameScoreDo {
return g.withDO(g.DO.Session(config))
}
func (g gameScoreDo) Clauses(conds ...clause.Expression) IGameScoreDo {
return g.withDO(g.DO.Clauses(conds...))
}
func (g gameScoreDo) Returning(value interface{}, columns ...string) IGameScoreDo {
return g.withDO(g.DO.Returning(value, columns...))
}
func (g gameScoreDo) Not(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Not(conds...))
}
func (g gameScoreDo) Or(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Or(conds...))
}
func (g gameScoreDo) Select(conds ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Select(conds...))
}
func (g gameScoreDo) Where(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Where(conds...))
}
func (g gameScoreDo) Order(conds ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Order(conds...))
}
func (g gameScoreDo) Distinct(cols ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Distinct(cols...))
}
func (g gameScoreDo) Omit(cols ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Omit(cols...))
}
func (g gameScoreDo) Join(table schema.Tabler, on ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Join(table, on...))
}
func (g gameScoreDo) LeftJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.LeftJoin(table, on...))
}
func (g gameScoreDo) RightJoin(table schema.Tabler, on ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.RightJoin(table, on...))
}
func (g gameScoreDo) Group(cols ...field.Expr) IGameScoreDo {
return g.withDO(g.DO.Group(cols...))
}
func (g gameScoreDo) Having(conds ...gen.Condition) IGameScoreDo {
return g.withDO(g.DO.Having(conds...))
}
func (g gameScoreDo) Limit(limit int) IGameScoreDo {
return g.withDO(g.DO.Limit(limit))
}
func (g gameScoreDo) Offset(offset int) IGameScoreDo {
return g.withDO(g.DO.Offset(offset))
}
func (g gameScoreDo) Scopes(funcs ...func(gen.Dao) gen.Dao) IGameScoreDo {
return g.withDO(g.DO.Scopes(funcs...))
}
func (g gameScoreDo) Unscoped() IGameScoreDo {
return g.withDO(g.DO.Unscoped())
}
func (g gameScoreDo) Create(values ...*model.GameScore) error {
if len(values) == 0 {
return nil
}
return g.DO.Create(values)
}
func (g gameScoreDo) CreateInBatches(values []*model.GameScore, batchSize int) error {
return g.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 (g gameScoreDo) Save(values ...*model.GameScore) error {
if len(values) == 0 {
return nil
}
return g.DO.Save(values)
}
func (g gameScoreDo) First() (*model.GameScore, error) {
if result, err := g.DO.First(); err != nil {
return nil, err
} else {
return result.(*model.GameScore), nil
}
}
func (g gameScoreDo) Take() (*model.GameScore, error) {
if result, err := g.DO.Take(); err != nil {
return nil, err
} else {
return result.(*model.GameScore), nil
}
}
func (g gameScoreDo) Last() (*model.GameScore, error) {
if result, err := g.DO.Last(); err != nil {
return nil, err
} else {
return result.(*model.GameScore), nil
}
}
func (g gameScoreDo) Find() ([]*model.GameScore, error) {
result, err := g.DO.Find()
return result.([]*model.GameScore), err
}
func (g gameScoreDo) FindInBatch(batchSize int, fc func(tx gen.Dao, batch int) error) (results []*model.GameScore, err error) {
buf := make([]*model.GameScore, 0, batchSize)
err = g.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 (g gameScoreDo) FindInBatches(result *[]*model.GameScore, batchSize int, fc func(tx gen.Dao, batch int) error) error {
return g.DO.FindInBatches(result, batchSize, fc)
}
func (g gameScoreDo) Attrs(attrs ...field.AssignExpr) IGameScoreDo {
return g.withDO(g.DO.Attrs(attrs...))
}
func (g gameScoreDo) Assign(attrs ...field.AssignExpr) IGameScoreDo {
return g.withDO(g.DO.Assign(attrs...))
}
func (g gameScoreDo) Joins(fields ...field.RelationField) IGameScoreDo {
for _, _f := range fields {
g = *g.withDO(g.DO.Joins(_f))
}
return &g
}
func (g gameScoreDo) Preload(fields ...field.RelationField) IGameScoreDo {
for _, _f := range fields {
g = *g.withDO(g.DO.Preload(_f))
}
return &g
}
func (g gameScoreDo) FirstOrInit() (*model.GameScore, error) {
if result, err := g.DO.FirstOrInit(); err != nil {
return nil, err
} else {
return result.(*model.GameScore), nil
}
}
func (g gameScoreDo) FirstOrCreate() (*model.GameScore, error) {
if result, err := g.DO.FirstOrCreate(); err != nil {
return nil, err
} else {
return result.(*model.GameScore), nil
}
}
func (g gameScoreDo) FindByPage(offset int, limit int) (result []*model.GameScore, count int64, err error) {
result, err = g.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 = g.Offset(-1).Limit(-1).Count()
return
}
func (g gameScoreDo) ScanByPage(result interface{}, offset int, limit int) (count int64, err error) {
count, err = g.Count()
if err != nil {
return
}
err = g.Offset(offset).Limit(limit).Scan(result)
return
}
func (g gameScoreDo) Scan(result interface{}) (err error) {
return g.DO.Scan(result)
}
func (g gameScoreDo) Delete(models ...*model.GameScore) (result gen.ResultInfo, err error) {
return g.DO.Delete(models)
}
func (g *gameScoreDo) withDO(do gen.Dao) *gameScoreDo {
g.DO = *do.(*gen.DO)
return g
}

127
gorm-gen/query/gen.go
View File

@ -1,127 +0,0 @@
// 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)
AppAccount *appAccount
AppUser *appUser
DouyinEcpmConfig *douyinEcpmConfig
GameScore *gameScore
)
func SetDefault(db *gorm.DB, opts ...gen.DOOption) {
*Q = *Use(db, opts...)
AppAccount = &Q.AppAccount
AppUser = &Q.AppUser
DouyinEcpmConfig = &Q.DouyinEcpmConfig
GameScore = &Q.GameScore
}
func Use(db *gorm.DB, opts ...gen.DOOption) *Query {
return &Query{
db: db,
AppAccount: newAppAccount(db, opts...),
AppUser: newAppUser(db, opts...),
DouyinEcpmConfig: newDouyinEcpmConfig(db, opts...),
GameScore: newGameScore(db, opts...),
}
}
type Query struct {
db *gorm.DB
AppAccount appAccount
AppUser appUser
DouyinEcpmConfig douyinEcpmConfig
GameScore gameScore
}
func (q *Query) Available() bool { return q.db != nil }
func (q *Query) clone(db *gorm.DB) *Query {
return &Query{
db: db,
AppAccount: q.AppAccount.clone(db),
AppUser: q.AppUser.clone(db),
DouyinEcpmConfig: q.DouyinEcpmConfig.clone(db),
GameScore: q.GameScore.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,
AppAccount: q.AppAccount.replaceDB(db),
AppUser: q.AppUser.replaceDB(db),
DouyinEcpmConfig: q.DouyinEcpmConfig.replaceDB(db),
GameScore: q.GameScore.replaceDB(db),
}
}
type queryCtx struct {
AppAccount IAppAccountDo
AppUser IAppUserDo
DouyinEcpmConfig IDouyinEcpmConfigDo
GameScore IGameScoreDo
}
func (q *Query) WithContext(ctx context.Context) *queryCtx {
return &queryCtx{
AppAccount: q.AppAccount.WithContext(ctx),
AppUser: q.AppUser.WithContext(ctx),
DouyinEcpmConfig: q.DouyinEcpmConfig.WithContext(ctx),
GameScore: q.GameScore.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
}