gorm/callbacks/query.go

283 lines
9.3 KiB
Go
Raw Normal View History

2020-02-02 09:40:44 +03:00
package callbacks
2020-02-04 03:56:15 +03:00
import (
2020-04-15 04:14:24 +03:00
"fmt"
2020-02-23 16:22:35 +03:00
"reflect"
2020-05-07 05:03:48 +03:00
"sort"
"strings"
2020-02-23 16:22:35 +03:00
2020-06-02 04:16:07 +03:00
"gorm.io/gorm"
"gorm.io/gorm/clause"
2020-02-04 03:56:15 +03:00
)
2020-02-02 09:40:44 +03:00
func Query(db *gorm.DB) {
2020-05-31 18:55:56 +03:00
if db.Error == nil {
2020-11-04 06:03:22 +03:00
BuildQuerySQL(db)
2020-04-15 04:14:24 +03:00
if !db.DryRun && db.Error == nil {
2020-06-01 16:26:23 +03:00
rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
if err != nil {
db.AddError(err)
return
}
defer func() {
db.AddError(rows.Close())
}()
2021-10-26 17:36:37 +03:00
gorm.Scan(rows, db, 0)
2020-06-01 16:26:23 +03:00
}
2020-05-31 18:55:56 +03:00
}
2020-05-31 14:23:32 +03:00
}
func BuildQuerySQL(db *gorm.DB) {
if db.Statement.Schema != nil {
2020-11-04 06:03:22 +03:00
for _, c := range db.Statement.Schema.QueryClauses {
db.Statement.AddClause(c)
2020-06-01 14:41:33 +03:00
}
}
if db.Statement.SQL.Len() == 0 {
2020-11-04 06:03:22 +03:00
db.Statement.SQL.Grow(100)
clauseSelect := clause.Select{Distinct: db.Statement.Distinct}
if db.Statement.ReflectValue.Kind() == reflect.Struct && db.Statement.ReflectValue.Type() == db.Statement.Schema.ModelType {
var conds []clause.Expression
for _, primaryField := range db.Statement.Schema.PrimaryFields {
if v, isZero := primaryField.ValueOf(db.Statement.Context, db.Statement.ReflectValue); !isZero {
2020-11-04 06:03:22 +03:00
conds = append(conds, clause.Eq{Column: clause.Column{Table: db.Statement.Table, Name: primaryField.DBName}, Value: v})
}
2020-04-15 04:14:24 +03:00
}
2020-11-04 06:03:22 +03:00
if len(conds) > 0 {
db.Statement.AddClause(clause.Where{Exprs: conds})
2020-07-19 16:48:58 +03:00
}
}
2020-11-04 06:03:22 +03:00
if len(db.Statement.Selects) > 0 {
clauseSelect.Columns = make([]clause.Column, len(db.Statement.Selects))
for idx, name := range db.Statement.Selects {
if db.Statement.Schema == nil {
clauseSelect.Columns[idx] = clause.Column{Name: name, Raw: true}
} else if f := db.Statement.Schema.LookUpField(name); f != nil {
clauseSelect.Columns[idx] = clause.Column{Name: f.DBName}
} else {
clauseSelect.Columns[idx] = clause.Column{Name: name, Raw: true}
}
}
} else if db.Statement.Schema != nil && len(db.Statement.Omits) > 0 {
selectColumns, _ := db.Statement.SelectAndOmitColumns(false, false)
clauseSelect.Columns = make([]clause.Column, 0, len(db.Statement.Schema.DBNames))
for _, dbName := range db.Statement.Schema.DBNames {
if v, ok := selectColumns[dbName]; (ok && v) || !ok {
clauseSelect.Columns = append(clauseSelect.Columns, clause.Column{Table: db.Statement.Table, Name: dbName})
2020-11-04 06:03:22 +03:00
}
}
} else if db.Statement.Schema != nil && db.Statement.ReflectValue.IsValid() {
2020-11-20 10:44:39 +03:00
queryFields := db.QueryFields
if !queryFields {
switch db.Statement.ReflectValue.Kind() {
case reflect.Struct:
2020-11-20 10:44:39 +03:00
queryFields = db.Statement.ReflectValue.Type() != db.Statement.Schema.ModelType
case reflect.Slice:
2020-11-20 10:44:39 +03:00
queryFields = db.Statement.ReflectValue.Type().Elem() != db.Statement.Schema.ModelType
}
2020-11-20 10:44:39 +03:00
}
2020-11-20 10:44:39 +03:00
if queryFields {
2020-11-04 06:03:22 +03:00
stmt := gorm.Statement{DB: db}
// smaller struct
2020-11-20 10:44:39 +03:00
if err := stmt.Parse(db.Statement.Dest); err == nil && (db.QueryFields || stmt.Schema.ModelType != db.Statement.Schema.ModelType) {
2020-11-04 06:03:22 +03:00
clauseSelect.Columns = make([]clause.Column, len(stmt.Schema.DBNames))
2020-07-01 03:56:21 +03:00
2020-11-04 06:03:22 +03:00
for idx, dbName := range stmt.Schema.DBNames {
clauseSelect.Columns[idx] = clause.Column{Table: db.Statement.Table, Name: dbName}
2020-11-04 06:03:22 +03:00
}
}
2020-07-01 03:56:21 +03:00
}
}
2020-05-31 14:23:32 +03:00
2020-11-04 06:03:22 +03:00
// inline joins
fromClause := clause.From{}
if v, ok := db.Statement.Clauses["FROM"].Expression.(clause.From); ok {
fromClause = v
}
if len(db.Statement.Joins) != 0 || len(fromClause.Joins) != 0 {
if len(db.Statement.Selects) == 0 && len(db.Statement.Omits) == 0 && db.Statement.Schema != nil {
2020-11-04 06:03:22 +03:00
clauseSelect.Columns = make([]clause.Column, len(db.Statement.Schema.DBNames))
for idx, dbName := range db.Statement.Schema.DBNames {
clauseSelect.Columns[idx] = clause.Column{Table: db.Statement.Table, Name: dbName}
}
2020-05-31 14:23:32 +03:00
}
2020-04-15 04:14:24 +03:00
2020-11-04 06:03:22 +03:00
for _, join := range db.Statement.Joins {
if db.Statement.Schema == nil {
fromClause.Joins = append(fromClause.Joins, clause.Join{
2020-12-07 05:31:06 +03:00
Expression: clause.NamedExpr{SQL: join.Name, Vars: join.Conds},
2020-04-15 04:14:24 +03:00
})
2020-11-04 06:03:22 +03:00
} else if relation, ok := db.Statement.Schema.Relationships.Relations[join.Name]; ok {
tableAliasName := relation.Name
columnStmt := gorm.Statement{
Table: tableAliasName, DB: db, Schema: relation.FieldSchema,
Selects: join.Selects, Omits: join.Omits,
}
selectColumns, restricted := columnStmt.SelectAndOmitColumns(false, false)
2020-11-04 06:03:22 +03:00
for _, s := range relation.FieldSchema.DBNames {
if v, ok := selectColumns[s]; (ok && v) || (!ok && !restricted) {
clauseSelect.Columns = append(clauseSelect.Columns, clause.Column{
Table: tableAliasName,
Name: s,
Alias: tableAliasName + "__" + s,
})
}
2020-11-04 06:03:22 +03:00
}
2020-05-29 19:16:33 +03:00
2021-09-07 16:21:44 +03:00
exprs := make([]clause.Expression, len(relation.References))
for idx, ref := range relation.References {
if ref.OwnPrimaryKey {
exprs[idx] = clause.Eq{
Column: clause.Column{Table: clause.CurrentTable, Name: ref.PrimaryKey.DBName},
Value: clause.Column{Table: tableAliasName, Name: ref.ForeignKey.DBName},
}
} else {
if ref.PrimaryValue == "" {
2020-11-04 06:03:22 +03:00
exprs[idx] = clause.Eq{
2021-09-07 16:21:44 +03:00
Column: clause.Column{Table: clause.CurrentTable, Name: ref.ForeignKey.DBName},
Value: clause.Column{Table: tableAliasName, Name: ref.PrimaryKey.DBName},
2020-11-04 06:03:22 +03:00
}
} else {
2021-09-07 16:21:44 +03:00
exprs[idx] = clause.Eq{
Column: clause.Column{Table: tableAliasName, Name: ref.ForeignKey.DBName},
Value: ref.PrimaryValue,
2020-11-04 06:03:22 +03:00
}
2020-06-08 08:45:41 +03:00
}
2020-04-15 04:14:24 +03:00
}
2021-09-07 16:21:44 +03:00
}
{
onStmt := gorm.Statement{Table: tableAliasName, DB: db, Clauses: map[string]clause.Clause{}}
for _, c := range relation.FieldSchema.QueryClauses {
onStmt.AddClause(c)
2021-09-07 16:21:44 +03:00
}
if join.On != nil {
onStmt.AddClause(join.On)
}
if cs, ok := onStmt.Clauses["WHERE"]; ok {
if where, ok := cs.Expression.(clause.Where); ok {
where.Build(&onStmt)
if onSQL := onStmt.SQL.String(); onSQL != "" {
vars := onStmt.Vars
for idx, v := range vars {
bindvar := strings.Builder{}
onStmt.Vars = vars[0 : idx+1]
db.Dialector.BindVarTo(&bindvar, &onStmt, v)
onSQL = strings.Replace(onSQL, bindvar.String(), "?", 1)
}
exprs = append(exprs, clause.Expr{SQL: onSQL, Vars: vars})
}
}
}
2020-04-15 04:14:24 +03:00
}
2021-09-07 16:21:44 +03:00
fromClause.Joins = append(fromClause.Joins, clause.Join{
Type: join.JoinType,
2021-09-07 16:21:44 +03:00
Table: clause.Table{Name: relation.FieldSchema.Table, Alias: tableAliasName},
ON: clause.Where{Exprs: exprs},
})
2020-11-04 06:03:22 +03:00
} else {
fromClause.Joins = append(fromClause.Joins, clause.Join{
2020-12-07 05:31:06 +03:00
Expression: clause.NamedExpr{SQL: join.Name, Vars: join.Conds},
2020-11-04 06:03:22 +03:00
})
}
2020-05-31 14:23:32 +03:00
}
2020-04-15 04:14:24 +03:00
db.Statement.AddClause(fromClause)
db.Statement.Joins = nil
2020-11-04 06:03:22 +03:00
} else {
db.Statement.AddClauseIfNotExists(clause.From{})
}
2020-02-04 03:56:15 +03:00
2020-11-04 06:03:22 +03:00
db.Statement.AddClauseIfNotExists(clauseSelect)
2020-03-03 09:18:12 +03:00
2021-04-28 12:19:30 +03:00
db.Statement.Build(db.Statement.BuildClauses...)
2020-11-04 06:03:22 +03:00
}
2020-02-02 09:40:44 +03:00
}
func Preload(db *gorm.DB) {
2020-06-08 08:45:41 +03:00
if db.Error == nil && len(db.Statement.Preloads) > 0 {
2022-03-17 06:22:25 +03:00
if db.Statement.Schema == nil {
db.AddError(fmt.Errorf("%w when using preload", gorm.ErrModelValueRequired))
return
}
preloadMap := map[string]map[string][]interface{}{}
2020-06-08 08:45:41 +03:00
for name := range db.Statement.Preloads {
preloadFields := strings.Split(name, ".")
if preloadFields[0] == clause.Associations {
for _, rel := range db.Statement.Schema.Relationships.Relations {
if rel.Schema == db.Statement.Schema {
if _, ok := preloadMap[rel.Name]; !ok {
preloadMap[rel.Name] = map[string][]interface{}{}
}
if value := strings.TrimPrefix(strings.TrimPrefix(name, preloadFields[0]), "."); value != "" {
preloadMap[rel.Name][value] = db.Statement.Preloads[name]
}
}
}
} else {
if _, ok := preloadMap[preloadFields[0]]; !ok {
preloadMap[preloadFields[0]] = map[string][]interface{}{}
}
if value := strings.TrimPrefix(strings.TrimPrefix(name, preloadFields[0]), "."); value != "" {
preloadMap[preloadFields[0]][value] = db.Statement.Preloads[name]
}
2020-05-07 05:03:48 +03:00
}
2020-06-08 08:45:41 +03:00
}
2020-05-07 05:03:48 +03:00
preloadNames := make([]string, 0, len(preloadMap))
2020-06-08 08:45:41 +03:00
for key := range preloadMap {
preloadNames = append(preloadNames, key)
2020-06-08 08:45:41 +03:00
}
sort.Strings(preloadNames)
preloadDB := db.Session(&gorm.Session{Context: db.Statement.Context, NewDB: true, SkipHooks: db.Statement.SkipHooks, Initialized: true})
db.Statement.Settings.Range(func(k, v interface{}) bool {
preloadDB.Statement.Settings.Store(k, v)
return true
})
if err := preloadDB.Statement.Parse(db.Statement.Dest); err != nil {
return
}
preloadDB.Statement.ReflectValue = db.Statement.ReflectValue
preloadDB.Statement.Unscoped = db.Statement.Unscoped
2020-06-08 08:45:41 +03:00
for _, name := range preloadNames {
if rel := preloadDB.Statement.Schema.Relationships.Relations[name]; rel != nil {
2022-05-04 13:57:53 +03:00
db.AddError(preload(preloadDB.Table("").Session(&gorm.Session{Context: db.Statement.Context, SkipHooks: db.Statement.SkipHooks}), rel, append(db.Statement.Preloads[name], db.Statement.Preloads[clause.Associations]...), preloadMap[name]))
} else {
db.AddError(fmt.Errorf("%s: %w for schema %s", name, gorm.ErrUnsupportedRelation, db.Statement.Schema.Name))
}
2020-05-07 05:03:48 +03:00
}
}
2020-02-02 09:40:44 +03:00
}
func AfterQuery(db *gorm.DB) {
if db.Error == nil && db.Statement.Schema != nil && !db.Statement.SkipHooks && db.Statement.Schema.AfterFind && db.RowsAffected > 0 {
callMethod(db, func(value interface{}, tx *gorm.DB) bool {
2020-08-27 10:03:57 +03:00
if i, ok := value.(AfterFindInterface); ok {
db.AddError(i.AfterFind(tx))
return true
2020-02-23 16:22:35 +03:00
}
return false
})
2020-02-23 16:22:35 +03:00
}
2020-02-02 09:40:44 +03:00
}