tablet/gorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor if...else and for logic

Browse Source
This commit is contained in:
daheige 2021-09-07 22:07:04 +08:00
parent a89d4d8fd5
commit 61bc71a53b
4 changed files with 149 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
callbacks/create.go
View File

@ -62,46 +62,57 @@ func Create(config *Config) func(db *gorm.DB) {
return return
} }
db.RowsAffected, _ = result.RowsAffected() db.RowsAffected, err = result.RowsAffected()
if err != nil {
db.AddError(err)
return
}
if db.RowsAffected != 0 && db.Statement.Schema != nil && if db.RowsAffected != 0 && db.Statement.Schema != nil &&
db.Statement.Schema.PrioritizedPrimaryField != nil && db.Statement.Schema.PrioritizedPrimaryField.HasDefaultValue { db.Statement.Schema.PrioritizedPrimaryField != nil && db.Statement.Schema.PrioritizedPrimaryField.HasDefaultValue {
if insertID, err := result.LastInsertId(); err == nil && insertID > 0 { insertID, err := result.LastInsertId()
switch db.Statement.ReflectValue.Kind() { if err != nil {
case reflect.Slice, reflect.Array: db.AddError(err)
if config.LastInsertIDReversed { return
for i := db.Statement.ReflectValue.Len() - 1; i >= 0; i-- { }
rv := db.Statement.ReflectValue.Index(i)
if reflect.Indirect(rv).Kind() != reflect.Struct {
break
}
_, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(rv) if insertID <= 0 {
if isZero { // maybe log record
db.Statement.Schema.PrioritizedPrimaryField.Set(rv, insertID) return
insertID -= db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement }
}
switch db.Statement.ReflectValue.Kind() {
case reflect.Slice, reflect.Array:
if config.LastInsertIDReversed {
for i := db.Statement.ReflectValue.Len() - 1; i >= 0; i-- {
rv := db.Statement.ReflectValue.Index(i)
if reflect.Indirect(rv).Kind() != reflect.Struct {
break
} }
} else {
for i := 0; i < db.Statement.ReflectValue.Len(); i++ {
rv := db.Statement.ReflectValue.Index(i)
if reflect.Indirect(rv).Kind() != reflect.Struct {
break
}
if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(rv); isZero { _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(rv)
db.Statement.Schema.PrioritizedPrimaryField.Set(rv, insertID) if isZero {
insertID += db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement db.Statement.Schema.PrioritizedPrimaryField.Set(rv, insertID)
} insertID -= db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
} }
} }
case reflect.Struct: } else {
if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.ReflectValue); isZero { for i := 0; i < db.Statement.ReflectValue.Len(); i++ {
db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.ReflectValue, insertID) rv := db.Statement.ReflectValue.Index(i)
if reflect.Indirect(rv).Kind() != reflect.Struct {
break
}
if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(rv); isZero {
db.Statement.Schema.PrioritizedPrimaryField.Set(rv, insertID)
insertID += db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
}
} }
} }
} else { case reflect.Struct:
db.AddError(err) if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.ReflectValue); isZero {
db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.ReflectValue, insertID)
}
} }
} }
} }
@ -195,9 +206,14 @@ func CreateWithReturning(db *gorm.DB) {
} }
} }
} else if !db.DryRun && db.Error == nil { } else if !db.DryRun && db.Error == nil {
if result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...); err == nil { result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
db.RowsAffected, _ = result.RowsAffected() if err != nil {
} else { db.AddError(err)
return
}
db.RowsAffected, err = result.RowsAffected()
if err != nil {
db.AddError(err) db.AddError(err)
} }
} }

139
callbacks/delete.go
View File

@ -25,82 +25,87 @@ func BeforeDelete(db *gorm.DB) {
func DeleteBeforeAssociations(db *gorm.DB) { func DeleteBeforeAssociations(db *gorm.DB) {
if db.Error == nil && db.Statement.Schema != nil { if db.Error == nil && db.Statement.Schema != nil {
selectColumns, restricted := db.Statement.SelectAndOmitColumns(true, false) selectColumns, restricted := db.Statement.SelectAndOmitColumns(true, false)
if !restricted {
return
}
if restricted { for column, v := range selectColumns {
for column, v := range selectColumns { if !v {
if v { continue
if rel, ok := db.Statement.Schema.Relationships.Relations[column]; ok { }
switch rel.Type {
case schema.HasOne, schema.HasMany:
queryConds := rel.ToQueryConditions(db.Statement.ReflectValue)
modelValue := reflect.New(rel.FieldSchema.ModelType).Interface()
tx := db.Session(&gorm.Session{NewDB: true}).Model(modelValue)
withoutConditions := false
if db.Statement.Unscoped {
tx = tx.Unscoped()
}
if len(db.Statement.Selects) > 0 { rel, ok := db.Statement.Schema.Relationships.Relations[column]
selects := make([]string, 0, len(db.Statement.Selects)) if !ok {
for _, s := range db.Statement.Selects { continue
if s == clause.Associations { }
selects = append(selects, s)
} else if strings.HasPrefix(s, column+".") {
selects = append(selects, strings.TrimPrefix(s, column+"."))
}
}
if len(selects) > 0 { switch rel.Type {
tx = tx.Select(selects) case schema.HasOne, schema.HasMany:
} queryConds := rel.ToQueryConditions(db.Statement.ReflectValue)
} modelValue := reflect.New(rel.FieldSchema.ModelType).Interface()
tx := db.Session(&gorm.Session{NewDB: true}).Model(modelValue)
withoutConditions := false
if db.Statement.Unscoped {
tx = tx.Unscoped()
}
for _, cond := range queryConds { if len(db.Statement.Selects) > 0 {
if c, ok := cond.(clause.IN); ok && len(c.Values) == 0 { selects := make([]string, 0, len(db.Statement.Selects))
withoutConditions = true for _, s := range db.Statement.Selects {
break if s == clause.Associations {
} selects = append(selects, s)
} } else if columnPrefix := column + "."; strings.HasPrefix(s, columnPrefix) {
selects = append(selects, strings.TrimPrefix(s, columnPrefix))
if !withoutConditions {
if db.AddError(tx.Clauses(clause.Where{Exprs: queryConds}).Delete(modelValue).Error) != nil {
return
}
}
case schema.Many2Many:
var (
queryConds = make([]clause.Expression, 0, len(rel.References))
foreignFields = make([]*schema.Field, 0, len(rel.References))
relForeignKeys = make([]string, 0, len(rel.References))
modelValue = reflect.New(rel.JoinTable.ModelType).Interface()
table = rel.JoinTable.Table
tx = db.Session(&gorm.Session{NewDB: true}).Model(modelValue).Table(table)
)
for _, ref := range rel.References {
if ref.OwnPrimaryKey {
foreignFields = append(foreignFields, ref.PrimaryKey)
relForeignKeys = append(relForeignKeys, ref.ForeignKey.DBName)
} else if ref.PrimaryValue != "" {
queryConds = append(queryConds, clause.Eq{
Column: clause.Column{Table: rel.JoinTable.Table, Name: ref.ForeignKey.DBName},
Value: ref.PrimaryValue,
})
}
}
_, foreignValues := schema.GetIdentityFieldValuesMap(db.Statement.ReflectValue, foreignFields)
column, values := schema.ToQueryValues(table, relForeignKeys, foreignValues)
queryConds = append(queryConds, clause.IN{Column: column, Values: values})
if db.AddError(tx.Clauses(clause.Where{Exprs: queryConds}).Delete(modelValue).Error) != nil {
return
}
} }
} }
if len(selects) > 0 {
tx = tx.Select(selects)
}
}
for _, cond := range queryConds {
if c, ok := cond.(clause.IN); ok && len(c.Values) == 0 {
withoutConditions = true
break
}
}
if !withoutConditions && db.AddError(tx.Clauses(clause.Where{Exprs: queryConds}).Delete(modelValue).Error) != nil {
return
}
case schema.Many2Many:
var (
queryConds = make([]clause.Expression, 0, len(rel.References))
foreignFields = make([]*schema.Field, 0, len(rel.References))
relForeignKeys = make([]string, 0, len(rel.References))
modelValue = reflect.New(rel.JoinTable.ModelType).Interface()
table = rel.JoinTable.Table
tx = db.Session(&gorm.Session{NewDB: true}).Model(modelValue).Table(table)
)
for _, ref := range rel.References {
if ref.OwnPrimaryKey {
foreignFields = append(foreignFields, ref.PrimaryKey)
relForeignKeys = append(relForeignKeys, ref.ForeignKey.DBName)
} else if ref.PrimaryValue != "" {
queryConds = append(queryConds, clause.Eq{
Column: clause.Column{Table: rel.JoinTable.Table, Name: ref.ForeignKey.DBName},
Value: ref.PrimaryValue,
})
}
}
_, foreignValues := schema.GetIdentityFieldValuesMap(db.Statement.ReflectValue, foreignFields)
column, values := schema.ToQueryValues(table, relForeignKeys, foreignValues)
queryConds = append(queryConds, clause.IN{Column: column, Values: values})
if db.AddError(tx.Clauses(clause.Where{Exprs: queryConds}).Delete(modelValue).Error) != nil {
return
} }
} }
} }
} }
} }

38
callbacks/preload.go
View File

@ -145,27 +145,29 @@ func preload(db *gorm.DB, rel *schema.Relationship, conds []interface{}, preload
fieldValues[idx], _ = field.ValueOf(elem) fieldValues[idx], _ = field.ValueOf(elem)
} }
if datas, ok := identityMap[utils.ToStringKey(fieldValues...)]; ok { datas, ok := identityMap[utils.ToStringKey(fieldValues...)]
for _, data := range datas { if !ok {
reflectFieldValue := rel.Field.ReflectValueOf(data) db.AddError(fmt.Errorf("failed to assign association %#v, make sure foreign fields exists",
if reflectFieldValue.Kind() == reflect.Ptr && reflectFieldValue.IsNil() { elem.Interface()))
reflectFieldValue.Set(reflect.New(rel.Field.FieldType.Elem())) }
}
reflectFieldValue = reflect.Indirect(reflectFieldValue) for _, data := range datas {
switch reflectFieldValue.Kind() { reflectFieldValue := rel.Field.ReflectValueOf(data)
case reflect.Struct: if reflectFieldValue.Kind() == reflect.Ptr && reflectFieldValue.IsNil() {
rel.Field.Set(data, reflectResults.Index(i).Interface()) reflectFieldValue.Set(reflect.New(rel.Field.FieldType.Elem()))
case reflect.Slice, reflect.Array: }
if reflectFieldValue.Type().Elem().Kind() == reflect.Ptr {
rel.Field.Set(data, reflect.Append(reflectFieldValue, elem).Interface()) reflectFieldValue = reflect.Indirect(reflectFieldValue)
} else { switch reflectFieldValue.Kind() {
rel.Field.Set(data, reflect.Append(reflectFieldValue, elem.Elem()).Interface()) case reflect.Struct:
} rel.Field.Set(data, elem.Interface())
case reflect.Slice, reflect.Array:
if reflectFieldValue.Type().Elem().Kind() == reflect.Ptr {
rel.Field.Set(data, reflect.Append(reflectFieldValue, elem).Interface())
} else {
rel.Field.Set(data, reflect.Append(reflectFieldValue, elem.Elem()).Interface())
} }
} }
} else {
db.AddError(fmt.Errorf("failed to assign association %#v, make sure foreign fields exists", elem.Interface()))
} }
} }
} }

15
callbacks/update.go
View File

@ -61,11 +61,12 @@ func Update(db *gorm.DB) {
if db.Statement.SQL.String() == "" { if db.Statement.SQL.String() == "" {
db.Statement.SQL.Grow(180) db.Statement.SQL.Grow(180)
db.Statement.AddClauseIfNotExists(clause.Update{}) db.Statement.AddClauseIfNotExists(clause.Update{})
if set := ConvertToAssignments(db.Statement); len(set) != 0 { set := ConvertToAssignments(db.Statement)
db.Statement.AddClause(set) if len(set) == 0 {
} else {
return return
} }
db.Statement.AddClause(set)
db.Statement.Build(db.Statement.BuildClauses...) db.Statement.Build(db.Statement.BuildClauses...)
} }
@ -76,12 +77,12 @@ func Update(db *gorm.DB) {
if !db.DryRun && db.Error == nil { if !db.DryRun && db.Error == nil {
result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...) result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
if err != nil {
if err == nil {
db.RowsAffected, _ = result.RowsAffected()
} else {
db.AddError(err) db.AddError(err)
return
} }
db.RowsAffected, _ = result.RowsAffected()
} }
} }
} }