From 5fe32d593fad1bd8005c5fbc90489c9174ce73d6 Mon Sep 17 00:00:00 2001 From: Jinzhu Date: Mon, 21 Oct 2019 20:20:38 +0800 Subject: [PATCH 01/16] Escape table name for mysql HasTable --- dialect_mysql.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/dialect_mysql.go b/dialect_mysql.go index da46d586..ee9a43d3 100644 --- a/dialect_mysql.go +++ b/dialect_mysql.go @@ -165,7 +165,7 @@ func (s mysql) HasForeignKey(tableName string, foreignKeyName string) bool { func (s mysql) HasTable(tableName string) bool { currentDatabase, tableName := currentDatabaseAndTable(&s, tableName) var name string - if err := s.db.QueryRow(fmt.Sprintf("SHOW TABLES FROM %s WHERE Tables_in_%s = ?", currentDatabase, currentDatabase), tableName).Scan(&name); err != nil { + if err := s.db.QueryRow(fmt.Sprintf("SHOW TABLES FROM `%s` WHERE `Tables_in_%s` = ?", currentDatabase, currentDatabase), tableName).Scan(&name); err != nil { if err == sql.ErrNoRows { return false } From 795328fedc12a34cd2ea7483b2d8ee618bca46c6 Mon Sep 17 00:00:00 2001 From: FWangZil <779158078@qq.com> Date: Mon, 21 Oct 2019 20:45:38 +0800 Subject: [PATCH 02/16] fix(HasTable): database name (#2717) * fix(HasTable): database name allow mysql database name with '-' character * docs: add comment --- dialect_mysql.go | 1 + 1 file changed, 1 insertion(+) diff --git a/dialect_mysql.go b/dialect_mysql.go index ee9a43d3..ab6a8a91 100644 --- a/dialect_mysql.go +++ b/dialect_mysql.go @@ -165,6 +165,7 @@ func (s mysql) HasForeignKey(tableName string, foreignKeyName string) bool { func (s mysql) HasTable(tableName string) bool { currentDatabase, tableName := currentDatabaseAndTable(&s, tableName) var name string + // allow mysql database name with '-' character if err := s.db.QueryRow(fmt.Sprintf("SHOW TABLES FROM `%s` WHERE `Tables_in_%s` = ?", currentDatabase, currentDatabase), tableName).Scan(&name); err != nil { if err == sql.ErrNoRows { return false From 530711e724f3d4c678abc73f84be52c807e3df69 Mon Sep 17 00:00:00 2001 From: Ruben de Vries Date: Tue, 22 Oct 2019 11:27:30 +0200 Subject: [PATCH 03/16] fix a race condition on IsForeignKey that is being detected by -race sometimes. --- model_struct.go | 19 ++++++++- model_struct_test.go | 93 ++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 110 insertions(+), 2 deletions(-) create mode 100644 model_struct_test.go diff --git a/model_struct.go b/model_struct.go index 5234b287..d9e2e90f 100644 --- a/model_struct.go +++ b/model_struct.go @@ -17,6 +17,10 @@ var DefaultTableNameHandler = func(db *DB, defaultTableName string) string { return defaultTableName } +// lock for mutating global cached model metadata +var structsLock sync.Mutex + +// global cache of model metadata var modelStructsMap sync.Map // ModelStruct model definition @@ -419,8 +423,12 @@ func (scope *Scope) GetModelStruct() *ModelStruct { for idx, foreignKey := range foreignKeys { if foreignField := getForeignField(foreignKey, toFields); foreignField != nil { if associationField := getForeignField(associationForeignKeys[idx], modelStruct.StructFields); associationField != nil { - // source foreign keys + // mark field as foreignkey, use global lock to avoid race + structsLock.Lock() foreignField.IsForeignKey = true + structsLock.Unlock() + + // association foreign keys relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, associationField.Name) relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, associationField.DBName) @@ -523,8 +531,12 @@ func (scope *Scope) GetModelStruct() *ModelStruct { for idx, foreignKey := range foreignKeys { if foreignField := getForeignField(foreignKey, toFields); foreignField != nil { if scopeField := getForeignField(associationForeignKeys[idx], modelStruct.StructFields); scopeField != nil { + // mark field as foreignkey, use global lock to avoid race + structsLock.Lock() foreignField.IsForeignKey = true - // source foreign keys + structsLock.Unlock() + + // association foreign keys relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, scopeField.Name) relationship.AssociationForeignDBNames = append(relationship.AssociationForeignDBNames, scopeField.DBName) @@ -582,7 +594,10 @@ func (scope *Scope) GetModelStruct() *ModelStruct { for idx, foreignKey := range foreignKeys { if foreignField := getForeignField(foreignKey, modelStruct.StructFields); foreignField != nil { if associationField := getForeignField(associationForeignKeys[idx], toFields); associationField != nil { + // mark field as foreignkey, use global lock to avoid race + structsLock.Lock() foreignField.IsForeignKey = true + structsLock.Unlock() // association foreign keys relationship.AssociationForeignFieldNames = append(relationship.AssociationForeignFieldNames, associationField.Name) diff --git a/model_struct_test.go b/model_struct_test.go new file mode 100644 index 00000000..2ae419a0 --- /dev/null +++ b/model_struct_test.go @@ -0,0 +1,93 @@ +package gorm_test + +import ( + "sync" + "testing" + + "github.com/jinzhu/gorm" +) + +type ModelA struct { + gorm.Model + Name string + + ModelCs []ModelC `gorm:"foreignkey:OtherAID"` +} + +type ModelB struct { + gorm.Model + Name string + + ModelCs []ModelC `gorm:"foreignkey:OtherBID"` +} + +type ModelC struct { + gorm.Model + Name string + + OtherAID uint64 + OtherA *ModelA `gorm:"foreignkey:OtherAID"` + OtherBID uint64 + OtherB *ModelB `gorm:"foreignkey:OtherBID"` +} + +// This test will try to cause a race condition on the model's foreignkey metadata +func TestModelStructRaceSameModel(t *testing.T) { + // use a WaitGroup to execute as much in-sync as possible + // it's more likely to hit a race condition than without + n := 32 + start := sync.WaitGroup{} + start.Add(n) + + // use another WaitGroup to know when the test is done + done := sync.WaitGroup{} + done.Add(n) + + for i := 0; i < n; i++ { + go func() { + start.Wait() + + // call GetStructFields, this had a race condition before we fixed it + DB.NewScope(&ModelA{}).GetStructFields() + + done.Done() + }() + + start.Done() + } + + done.Wait() +} + +// This test will try to cause a race condition on the model's foreignkey metadata +func TestModelStructRaceDifferentModel(t *testing.T) { + // use a WaitGroup to execute as much in-sync as possible + // it's more likely to hit a race condition than without + n := 32 + start := sync.WaitGroup{} + start.Add(n) + + // use another WaitGroup to know when the test is done + done := sync.WaitGroup{} + done.Add(n) + + for i := 0; i < n; i++ { + i := i + go func() { + start.Wait() + + // call GetStructFields, this had a race condition before we fixed it + if i%2 == 0 { + DB.NewScope(&ModelA{}).GetStructFields() + } else { + DB.NewScope(&ModelB{}).GetStructFields() + } + + done.Done() + }() + + start.Done() + } + + done.Wait() +} From d926a05bec9ab9ee6f8bc6d865c1ccdf9350c74b Mon Sep 17 00:00:00 2001 From: "kouha.shu" Date: Wed, 23 Oct 2019 10:38:05 +0900 Subject: [PATCH 04/16] add warning comment --- main.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/main.go b/main.go index eac28f8a..5dda8838 100644 --- a/main.go +++ b/main.go @@ -433,7 +433,8 @@ func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB { return c } -// Update update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update +// Update update attributes with callbacks. refer: https://jinzhu.github.io/gorm/crud.html#update +// WARNING when update with struct, GORM will not update fields that with zero value func (s *DB) Update(attrs ...interface{}) *DB { return s.Updates(toSearchableMap(attrs...), true) } @@ -480,6 +481,7 @@ func (s *DB) Create(value interface{}) *DB { } // Delete delete value match given conditions, if the value has primary key, then will including the primary key as condition +// WARNING If model has DeletedAt field, GORM will only set field DeletedAt's value to current time func (s *DB) Delete(value interface{}, where ...interface{}) *DB { return s.NewScope(value).inlineCondition(where...).callCallbacks(s.parent.callbacks.deletes).db } From 2ee239a4c07c9e3f9948500cf01f667e89a7986d Mon Sep 17 00:00:00 2001 From: "kouha.shu" Date: Wed, 23 Oct 2019 10:40:34 +0900 Subject: [PATCH 05/16] Update main.go --- main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/main.go b/main.go index 5dda8838..e39a868a 100644 --- a/main.go +++ b/main.go @@ -433,7 +433,7 @@ func (s *DB) FirstOrCreate(out interface{}, where ...interface{}) *DB { return c } -// Update update attributes with callbacks. refer: https://jinzhu.github.io/gorm/crud.html#update +// Update update attributes with callbacks, refer: https://jinzhu.github.io/gorm/crud.html#update // WARNING when update with struct, GORM will not update fields that with zero value func (s *DB) Update(attrs ...interface{}) *DB { return s.Updates(toSearchableMap(attrs...), true) From c46c01c11689fa240dc70483f00ffb10dab9141f Mon Sep 17 00:00:00 2001 From: Dom Narducci Date: Fri, 25 Oct 2019 13:51:29 -0700 Subject: [PATCH 06/16] Log callback registration if logger exists for consistency --- callback.go | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/callback.go b/callback.go index 4d8e72c0..56b2064a 100644 --- a/callback.go +++ b/callback.go @@ -101,6 +101,12 @@ func (cp *CallbackProcessor) Register(callbackName string, callback func(scope * } } + if cp.logger != nil { + // note cp.logger will be nil during the default gorm callback registrations + // as they occur within init() blocks. However, any user-registered callbacks + // will happen after cp.logger exists (as the default logger or user-specified). + cp.logger.Print("info", fmt.Sprintf("[info] registering callback `%v` from %v", callbackName, fileWithLineNum())) + } cp.name = callbackName cp.processor = &callback cp.parent.processors = append(cp.parent.processors, cp) From 59408390c2dce9ca8b48fae08937213e72b24f9a Mon Sep 17 00:00:00 2001 From: Jason Lee Date: Tue, 19 Nov 2019 16:08:00 +0800 Subject: [PATCH 07/16] Add `db.Transaction` method for create Transaction block. (#2767) * Add `db.Transaction` method for create Transaction block. example: ```go func CreateAnimals(db *gorm.DB) error { db.Transaction(func(tx *gorm.DB) error { if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil { // return any error will rollback return err } if err := tx.Create(&Animal{Name: "Lion"}).Error; err != nil { return err } // return nil will commit return nil }) } ``` * Ensure rollback when commit has error. --- main.go | 25 ++++++++++++++++++++++ main_test.go | 60 ++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 85 insertions(+) diff --git a/main.go b/main.go index e39a868a..48d22c85 100644 --- a/main.go +++ b/main.go @@ -525,6 +525,31 @@ func (s *DB) Debug() *DB { return s.clone().LogMode(true) } +// Transaction start a transaction as a block, +// return error will rollback, otherwise to commit. +func (s *DB) Transaction(fc func(tx *DB) error) (err error) { + tx := s.Begin() + defer func() { + if r := recover(); r != nil { + err = fmt.Errorf("%s", r) + tx.Rollback() + return + } + }() + + err = fc(tx) + + if err == nil { + err = tx.Commit().Error + } + + // Makesure rollback when Block error or Commit error + if err != nil { + tx.Rollback() + } + return +} + // Begin begins a transaction func (s *DB) Begin() *DB { return s.BeginTx(context.Background(), &sql.TxOptions{}) diff --git a/main_test.go b/main_test.go index 68bf7419..134672b7 100644 --- a/main_test.go +++ b/main_test.go @@ -8,6 +8,7 @@ import ( "context" "database/sql" "database/sql/driver" + "errors" "fmt" "os" "path/filepath" @@ -469,6 +470,65 @@ func TestTransaction(t *testing.T) { } } +func TestTransactionWithBlock(t *testing.T) { + // rollback + err := DB.Transaction(func(tx *gorm.DB) error { + u := User{Name: "transcation"} + if err := tx.Save(&u).Error; err != nil { + t.Errorf("No error should raise") + } + + if err := tx.First(&User{}, "name = ?", "transcation").Error; err != nil { + t.Errorf("Should find saved record") + } + + return errors.New("the error message") + }) + + if err.Error() != "the error message" { + t.Errorf("Transaction return error will equal the block returns error") + } + + if err := DB.First(&User{}, "name = ?", "transcation").Error; err == nil { + t.Errorf("Should not find record after rollback") + } + + // commit + DB.Transaction(func(tx *gorm.DB) error { + u2 := User{Name: "transcation-2"} + if err := tx.Save(&u2).Error; err != nil { + t.Errorf("No error should raise") + } + + if err := tx.First(&User{}, "name = ?", "transcation-2").Error; err != nil { + t.Errorf("Should find saved record") + } + return nil + }) + + if err := DB.First(&User{}, "name = ?", "transcation-2").Error; err != nil { + t.Errorf("Should be able to find committed record") + } + + // panic will rollback + DB.Transaction(func(tx *gorm.DB) error { + u3 := User{Name: "transcation-3"} + if err := tx.Save(&u3).Error; err != nil { + t.Errorf("No error should raise") + } + + if err := tx.First(&User{}, "name = ?", "transcation-3").Error; err != nil { + t.Errorf("Should find saved record") + } + + panic("force panic") + }) + + if err := DB.First(&User{}, "name = ?", "transcation").Error; err == nil { + t.Errorf("Should not find record after panic rollback") + } +} + func TestTransaction_NoErrorOnRollbackAfterCommit(t *testing.T) { tx := DB.Begin() u := User{Name: "transcation"} From 23f6840776b08a33b8eb1394616abee31a4c9e98 Mon Sep 17 00:00:00 2001 From: zaneli Date: Thu, 31 Oct 2019 02:51:26 +0900 Subject: [PATCH 08/16] Add limit and offset parse error --- dialect.go | 2 +- dialect_common.go | 19 ++++++++++-- dialect_mysql.go | 15 ++++++--- dialects/mssql/mssql.go | 17 +++++++++-- query_test.go | 68 +++++++++++++++++++++++++++++++++++++++++ scope.go | 4 ++- 6 files changed, 113 insertions(+), 12 deletions(-) diff --git a/dialect.go b/dialect.go index b6f95df7..749587f4 100644 --- a/dialect.go +++ b/dialect.go @@ -37,7 +37,7 @@ type Dialect interface { ModifyColumn(tableName string, columnName string, typ string) error // LimitAndOffsetSQL return generated SQL with Limit and Offset, as mssql has special case - LimitAndOffsetSQL(limit, offset interface{}) string + LimitAndOffsetSQL(limit, offset interface{}) (string, error) // SelectFromDummyTable return select values, for most dbs, `SELECT values` just works, mysql needs `SELECT value FROM DUAL` SelectFromDummyTable() string // LastInsertIDOutputInterstitial most dbs support LastInsertId, but mssql needs to use `OUTPUT` diff --git a/dialect_common.go b/dialect_common.go index 16da76dc..950c1986 100644 --- a/dialect_common.go +++ b/dialect_common.go @@ -139,14 +139,23 @@ func (s commonDialect) CurrentDatabase() (name string) { return } -func (commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string) { +// LimitAndOffsetSQL return generated SQL with Limit and Offset +func (s commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) { if limit != nil { - if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit >= 0 { + parsedLimit, err := s.parseInt(limit) + if err != nil { + return "", err + } + if parsedLimit >= 0 { sql += fmt.Sprintf(" LIMIT %d", parsedLimit) } } if offset != nil { - if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset >= 0 { + parsedOffset, err := s.parseInt(offset) + if err != nil { + return "", err + } + if parsedOffset >= 0 { sql += fmt.Sprintf(" OFFSET %d", parsedOffset) } } @@ -181,6 +190,10 @@ func (commonDialect) NormalizeIndexAndColumn(indexName, columnName string) (stri return indexName, columnName } +func (commonDialect) parseInt(value interface{}) (int64, error) { + return strconv.ParseInt(fmt.Sprint(value), 0, 0) +} + // IsByteArrayOrSlice returns true of the reflected value is an array or slice func IsByteArrayOrSlice(value reflect.Value) bool { return (value.Kind() == reflect.Array || value.Kind() == reflect.Slice) && value.Type().Elem() == reflect.TypeOf(uint8(0)) diff --git a/dialect_mysql.go b/dialect_mysql.go index ab6a8a91..b4467ffa 100644 --- a/dialect_mysql.go +++ b/dialect_mysql.go @@ -6,7 +6,6 @@ import ( "fmt" "reflect" "regexp" - "strconv" "strings" "time" "unicode/utf8" @@ -140,13 +139,21 @@ func (s mysql) ModifyColumn(tableName string, columnName string, typ string) err return err } -func (s mysql) LimitAndOffsetSQL(limit, offset interface{}) (sql string) { +func (s mysql) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) { if limit != nil { - if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit >= 0 { + parsedLimit, err := s.parseInt(limit) + if err != nil { + return "", err + } + if parsedLimit >= 0 { sql += fmt.Sprintf(" LIMIT %d", parsedLimit) if offset != nil { - if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset >= 0 { + parsedOffset, err := s.parseInt(offset) + if err != nil { + return "", err + } + if parsedOffset >= 0 { sql += fmt.Sprintf(" OFFSET %d", parsedOffset) } } diff --git a/dialects/mssql/mssql.go b/dialects/mssql/mssql.go index eb79f7e7..43acb379 100644 --- a/dialects/mssql/mssql.go +++ b/dialects/mssql/mssql.go @@ -168,14 +168,25 @@ func (s mssql) CurrentDatabase() (name string) { return } -func (mssql) LimitAndOffsetSQL(limit, offset interface{}) (sql string) { +func (mssql) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) { + parseInt := func(value interface{}) (int64, error) { + return strconv.ParseInt(fmt.Sprint(value), 0, 0) + } if offset != nil { - if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset >= 0 { + parsedOffset, err := parseInt(offset) + if err != nil { + return "", err + } + if parsedOffset >= 0 { sql += fmt.Sprintf(" OFFSET %d ROWS", parsedOffset) } } if limit != nil { - if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit >= 0 { + parsedLimit, err := parseInt(limit) + if err != nil { + return "", err + } + if parsedLimit >= 0 { if sql == "" { // add default zero offset sql += " OFFSET 0 ROWS" diff --git a/query_test.go b/query_test.go index 15bf8b3c..a23a9e24 100644 --- a/query_test.go +++ b/query_test.go @@ -457,6 +457,74 @@ func TestOffset(t *testing.T) { } } +func TestLimitAndOffsetSQL(t *testing.T) { + user1 := User{Name: "TestLimitAndOffsetSQL1", Age: 10} + user2 := User{Name: "TestLimitAndOffsetSQL2", Age: 20} + user3 := User{Name: "TestLimitAndOffsetSQL3", Age: 30} + user4 := User{Name: "TestLimitAndOffsetSQL4", Age: 40} + user5 := User{Name: "TestLimitAndOffsetSQL5", Age: 50} + if err := DB.Save(&user1).Save(&user2).Save(&user3).Save(&user4).Save(&user5).Error; err != nil { + t.Fatal(err) + } + + tests := []struct { + name string + limit, offset interface{} + users []*User + ok bool + }{ + { + name: "OK", + limit: float64(2), + offset: float64(2), + users: []*User{ + &User{Name: "TestLimitAndOffsetSQL3", Age: 30}, + &User{Name: "TestLimitAndOffsetSQL2", Age: 20}, + }, + ok: true, + }, + { + name: "Limit parse error", + limit: float64(1000000), // 1e+06 + offset: float64(2), + ok: false, + }, + { + name: "Offset parse error", + limit: float64(2), + offset: float64(1000000), // 1e+06 + ok: false, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + var users []*User + err := DB.Where("name LIKE ?", "TestLimitAndOffsetSQL%").Order("age desc").Limit(tt.limit).Offset(tt.offset).Find(&users).Error + if tt.ok { + if err != nil { + t.Errorf("error expected nil, but got %v", err) + } + if len(users) != len(tt.users) { + t.Errorf("users length expected %d, but got %d", len(tt.users), len(users)) + } + for i := range tt.users { + if users[i].Name != tt.users[i].Name { + t.Errorf("users[%d] name expected %s, but got %s", i, tt.users[i].Name, users[i].Name) + } + if users[i].Age != tt.users[i].Age { + t.Errorf("users[%d] age expected %d, but got %d", i, tt.users[i].Age, users[i].Age) + } + } + } else { + if err == nil { + t.Error("error expected not nil, but got nil") + } + } + }) + } +} + func TestOr(t *testing.T) { user1 := User{Name: "OrUser1", Age: 1} user2 := User{Name: "OrUser2", Age: 10} diff --git a/scope.go b/scope.go index eb7525b8..0e9dfd1c 100644 --- a/scope.go +++ b/scope.go @@ -797,7 +797,9 @@ func (scope *Scope) orderSQL() string { } func (scope *Scope) limitAndOffsetSQL() string { - return scope.Dialect().LimitAndOffsetSQL(scope.Search.limit, scope.Search.offset) + sql, err := scope.Dialect().LimitAndOffsetSQL(scope.Search.limit, scope.Search.offset) + scope.Err(err) + return sql } func (scope *Scope) groupSQL() string { From 9827710b60e717b1411611da5b1bf52476aa34cb Mon Sep 17 00:00:00 2001 From: Thomas Tacquet Date: Wed, 27 Nov 2019 15:51:23 +0100 Subject: [PATCH 09/16] bump go-sqlite3 to v1.12.0 to fix go1.13 issues --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 2d2fec37..87207be4 100644 --- a/go.mod +++ b/go.mod @@ -9,5 +9,5 @@ require ( github.com/jinzhu/inflection v1.0.0 github.com/jinzhu/now v1.0.1 github.com/lib/pq v1.1.1 - github.com/mattn/go-sqlite3 v1.11.0 + github.com/mattn/go-sqlite3 v1.12.0 ) diff --git a/go.sum b/go.sum index c43559bf..9c7e8a54 100644 --- a/go.sum +++ b/go.sum @@ -54,6 +54,8 @@ github.com/lib/pq v1.1.1 h1:sJZmqHoEaY7f+NPP8pgLB/WxulyR3fewgCM2qaSlBb4= github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/mattn/go-sqlite3 v1.11.0 h1:LDdKkqtYlom37fkvqs8rMPFKAMe8+SgjbwZ6ex1/A/Q= github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.12.0 h1:u/x3mp++qUxvYfulZ4HKOvVO0JWhk7HtE8lWhbGz/Do= +github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= From b543a11ca0f9768994c6be4328284b167c1d83ba Mon Sep 17 00:00:00 2001 From: Charles Strahan Date: Thu, 5 Dec 2019 03:54:32 -0600 Subject: [PATCH 10/16] transaction blocks: don't swallow panics (#2774) This improves upon #2767. Previously, the code would swallow any panics, which isn't ideal; panic is intended to be used when a critical error arises, where the process should fail fast instead of trying to limp along. This now defers the any recovery (if desired) to the client code. --- main.go | 11 ++++------- main_test.go | 29 ++++++++++++++++++++--------- 2 files changed, 24 insertions(+), 16 deletions(-) diff --git a/main.go b/main.go index 48d22c85..24fd8382 100644 --- a/main.go +++ b/main.go @@ -528,12 +528,12 @@ func (s *DB) Debug() *DB { // Transaction start a transaction as a block, // return error will rollback, otherwise to commit. func (s *DB) Transaction(fc func(tx *DB) error) (err error) { + panicked := true tx := s.Begin() defer func() { - if r := recover(); r != nil { - err = fmt.Errorf("%s", r) + // Make sure to rollback when panic, Block error or Commit error + if panicked || err != nil { tx.Rollback() - return } }() @@ -543,10 +543,7 @@ func (s *DB) Transaction(fc func(tx *DB) error) (err error) { err = tx.Commit().Error } - // Makesure rollback when Block error or Commit error - if err != nil { - tx.Rollback() - } + panicked = false return } diff --git a/main_test.go b/main_test.go index 134672b7..98ea4694 100644 --- a/main_test.go +++ b/main_test.go @@ -470,6 +470,15 @@ func TestTransaction(t *testing.T) { } } +func assertPanic(t *testing.T, f func()) { + defer func() { + if r := recover(); r == nil { + t.Errorf("The code did not panic") + } + }() + f() +} + func TestTransactionWithBlock(t *testing.T) { // rollback err := DB.Transaction(func(tx *gorm.DB) error { @@ -511,17 +520,19 @@ func TestTransactionWithBlock(t *testing.T) { } // panic will rollback - DB.Transaction(func(tx *gorm.DB) error { - u3 := User{Name: "transcation-3"} - if err := tx.Save(&u3).Error; err != nil { - t.Errorf("No error should raise") - } + assertPanic(t, func() { + DB.Transaction(func(tx *gorm.DB) error { + u3 := User{Name: "transcation-3"} + if err := tx.Save(&u3).Error; err != nil { + t.Errorf("No error should raise") + } - if err := tx.First(&User{}, "name = ?", "transcation-3").Error; err != nil { - t.Errorf("Should find saved record") - } + if err := tx.First(&User{}, "name = ?", "transcation-3").Error; err != nil { + t.Errorf("Should find saved record") + } - panic("force panic") + panic("force panic") + }) }) if err := DB.First(&User{}, "name = ?", "transcation").Error; err == nil { From 2c2fbb99e5234bd22f0659ad82104f6e9adcd63d Mon Sep 17 00:00:00 2001 From: Jinzhu Date: Thu, 5 Dec 2019 18:05:12 +0800 Subject: [PATCH 11/16] Upgrade go-sqlite to v2.0.1 --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 87207be4..4d6eb7fa 100644 --- a/go.mod +++ b/go.mod @@ -9,5 +9,5 @@ require ( github.com/jinzhu/inflection v1.0.0 github.com/jinzhu/now v1.0.1 github.com/lib/pq v1.1.1 - github.com/mattn/go-sqlite3 v1.12.0 + github.com/mattn/go-sqlite3 v2.0.1+incompatible ) diff --git a/go.sum b/go.sum index 9c7e8a54..a9ae14d5 100644 --- a/go.sum +++ b/go.sum @@ -56,6 +56,8 @@ github.com/mattn/go-sqlite3 v1.11.0 h1:LDdKkqtYlom37fkvqs8rMPFKAMe8+SgjbwZ6ex1/A github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/mattn/go-sqlite3 v1.12.0 h1:u/x3mp++qUxvYfulZ4HKOvVO0JWhk7HtE8lWhbGz/Do= github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v2.0.1+incompatible h1:xQ15muvnzGBHpIpdrNi1DA5x0+TcBZzsIDwmw9uTHzw= +github.com/mattn/go-sqlite3 v2.0.1+incompatible/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= From 32ec5c04a6884ad3d85b6e83a77ce66de1a71816 Mon Sep 17 00:00:00 2001 From: Thomas Tacquet Date: Wed, 27 Nov 2019 15:51:23 +0100 Subject: [PATCH 12/16] bump go-sqlite3 to v1.12.0 to fix go1.13 issues --- go.mod | 2 +- go.sum | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 2d2fec37..87207be4 100644 --- a/go.mod +++ b/go.mod @@ -9,5 +9,5 @@ require ( github.com/jinzhu/inflection v1.0.0 github.com/jinzhu/now v1.0.1 github.com/lib/pq v1.1.1 - github.com/mattn/go-sqlite3 v1.11.0 + github.com/mattn/go-sqlite3 v1.12.0 ) diff --git a/go.sum b/go.sum index c43559bf..9c7e8a54 100644 --- a/go.sum +++ b/go.sum @@ -54,6 +54,8 @@ github.com/lib/pq v1.1.1 h1:sJZmqHoEaY7f+NPP8pgLB/WxulyR3fewgCM2qaSlBb4= github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= github.com/mattn/go-sqlite3 v1.11.0 h1:LDdKkqtYlom37fkvqs8rMPFKAMe8+SgjbwZ6ex1/A/Q= github.com/mattn/go-sqlite3 v1.11.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.12.0 h1:u/x3mp++qUxvYfulZ4HKOvVO0JWhk7HtE8lWhbGz/Do= +github.com/mattn/go-sqlite3 v1.12.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= From 0aba7ff3a0bff05dc25ec027895b5e6789e28bb3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=B4=BE=E4=B8=80=E9=A5=BC?= Date: Thu, 5 Dec 2019 18:26:16 +0800 Subject: [PATCH 13/16] Beautify callback log output (#2749) --- logger.go | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/logger.go b/logger.go index a42f2727..b4a362ce 100644 --- a/logger.go +++ b/logger.go @@ -39,6 +39,15 @@ var LogFormatter = func(values ...interface{}) (messages []interface{}) { messages = []interface{}{source, currentTime} + if len(values) == 2 { + //remove the line break + currentTime = currentTime[1:] + //remove the brackets + source = fmt.Sprintf("\033[35m%v\033[0m", values[1]) + + messages = []interface{}{currentTime, source} + } + if level == "sql" { // duration messages = append(messages, fmt.Sprintf(" \033[36;1m[%.2fms]\033[0m ", float64(values[2].(time.Duration).Nanoseconds()/1e4)/100.0)) From e8c07b55316b12d028eecac5e9a49f1b16918e44 Mon Sep 17 00:00:00 2001 From: Shunsuke Otani Date: Thu, 5 Dec 2019 23:57:15 +0900 Subject: [PATCH 14/16] Set nopLogger to DefaultCallback for avoid nil pointer dereference (#2742) --- callback.go | 9 ++------- callbacks_test.go | 30 ++++++++++++++++++++++++++++++ logger.go | 4 ++++ 3 files changed, 36 insertions(+), 7 deletions(-) diff --git a/callback.go b/callback.go index 56b2064a..1f0e3c79 100644 --- a/callback.go +++ b/callback.go @@ -3,7 +3,7 @@ package gorm import "fmt" // DefaultCallback default callbacks defined by gorm -var DefaultCallback = &Callback{} +var DefaultCallback = &Callback{logger: nopLogger{}} // Callback is a struct that contains all CRUD callbacks // Field `creates` contains callbacks will be call when creating object @@ -101,12 +101,7 @@ func (cp *CallbackProcessor) Register(callbackName string, callback func(scope * } } - if cp.logger != nil { - // note cp.logger will be nil during the default gorm callback registrations - // as they occur within init() blocks. However, any user-registered callbacks - // will happen after cp.logger exists (as the default logger or user-specified). - cp.logger.Print("info", fmt.Sprintf("[info] registering callback `%v` from %v", callbackName, fileWithLineNum())) - } + cp.logger.Print("info", fmt.Sprintf("[info] registering callback `%v` from %v", callbackName, fileWithLineNum())) cp.name = callbackName cp.processor = &callback cp.parent.processors = append(cp.parent.processors, cp) diff --git a/callbacks_test.go b/callbacks_test.go index c1a1d5e4..bebd0e38 100644 --- a/callbacks_test.go +++ b/callbacks_test.go @@ -217,3 +217,33 @@ func TestGetCallback(t *testing.T) { t.Errorf("`gorm:test_callback_value` should be `3, true` but `%v, %v`", v, ok) } } + +func TestUseDefaultCallback(t *testing.T) { + createCallbackName := "gorm:test_use_default_callback_for_create" + gorm.DefaultCallback.Create().Register(createCallbackName, func(*gorm.Scope) { + // nop + }) + if gorm.DefaultCallback.Create().Get(createCallbackName) == nil { + t.Errorf("`%s` expected non-nil, but got nil", createCallbackName) + } + gorm.DefaultCallback.Create().Remove(createCallbackName) + if gorm.DefaultCallback.Create().Get(createCallbackName) != nil { + t.Errorf("`%s` expected nil, but got non-nil", createCallbackName) + } + + updateCallbackName := "gorm:test_use_default_callback_for_update" + scopeValueName := "gorm:test_use_default_callback_for_update_value" + gorm.DefaultCallback.Update().Register(updateCallbackName, func(scope *gorm.Scope) { + scope.Set(scopeValueName, 1) + }) + gorm.DefaultCallback.Update().Replace(updateCallbackName, func(scope *gorm.Scope) { + scope.Set(scopeValueName, 2) + }) + + scope := DB.NewScope(nil) + callback := gorm.DefaultCallback.Update().Get(updateCallbackName) + callback(scope) + if v, ok := scope.Get(scopeValueName); !ok || v != 2 { + t.Errorf("`%s` should be `2, true` but `%v, %v`", scopeValueName, v, ok) + } +} diff --git a/logger.go b/logger.go index b4a362ce..88e167dd 100644 --- a/logger.go +++ b/logger.go @@ -135,3 +135,7 @@ type Logger struct { func (logger Logger) Print(values ...interface{}) { logger.Println(LogFormatter(values...)...) } + +type nopLogger struct{} + +func (nopLogger) Print(values ...interface{}) {} From 11e2819f44a6b6e2b21119a9eaf451244abd808b Mon Sep 17 00:00:00 2001 From: Jinzhu Date: Thu, 5 Dec 2019 23:13:54 +0800 Subject: [PATCH 15/16] Extract parseInt --- dialect_common.go | 12 ++++-------- dialects/mssql/mssql.go | 19 ++++++++----------- 2 files changed, 12 insertions(+), 19 deletions(-) diff --git a/dialect_common.go b/dialect_common.go index 950c1986..d549510c 100644 --- a/dialect_common.go +++ b/dialect_common.go @@ -142,20 +142,16 @@ func (s commonDialect) CurrentDatabase() (name string) { // LimitAndOffsetSQL return generated SQL with Limit and Offset func (s commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) { if limit != nil { - parsedLimit, err := s.parseInt(limit) - if err != nil { + if parsedLimit, err := s.parseInt(limit); err != nil { return "", err - } - if parsedLimit >= 0 { + } else if parsedLimit >= 0 { sql += fmt.Sprintf(" LIMIT %d", parsedLimit) } } if offset != nil { - parsedOffset, err := s.parseInt(offset) - if err != nil { + if parsedOffset, err := s.parseInt(offset); err != nil { return "", err - } - if parsedOffset >= 0 { + } else if parsedOffset >= 0 { sql += fmt.Sprintf(" OFFSET %d", parsedOffset) } } diff --git a/dialects/mssql/mssql.go b/dialects/mssql/mssql.go index 43acb379..cb2714e0 100644 --- a/dialects/mssql/mssql.go +++ b/dialects/mssql/mssql.go @@ -168,25 +168,22 @@ func (s mssql) CurrentDatabase() (name string) { return } +func parseInt(value interface{}) (int64, error) { + return strconv.ParseInt(fmt.Sprint(value), 0, 0) +} + func (mssql) LimitAndOffsetSQL(limit, offset interface{}) (sql string, err error) { - parseInt := func(value interface{}) (int64, error) { - return strconv.ParseInt(fmt.Sprint(value), 0, 0) - } if offset != nil { - parsedOffset, err := parseInt(offset) - if err != nil { + if parsedOffset, err := parseInt(offset); err != nil { return "", err - } - if parsedOffset >= 0 { + } else if parsedOffset >= 0 { sql += fmt.Sprintf(" OFFSET %d ROWS", parsedOffset) } } if limit != nil { - parsedLimit, err := parseInt(limit) - if err != nil { + if parsedLimit, err := parseInt(limit); err != nil { return "", err - } - if parsedLimit >= 0 { + } else if parsedLimit >= 0 { if sql == "" { // add default zero offset sql += " OFFSET 0 ROWS" From 5490a87fe9f9d72a38cfa641e7965bf48f588b87 Mon Sep 17 00:00:00 2001 From: Jinzhu Date: Fri, 6 Dec 2019 00:01:40 +0800 Subject: [PATCH 16/16] Should use global NowFunc when trace SQL --- callback_create.go | 2 +- callback_query.go | 2 +- scope.go | 6 +++--- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/callback_create.go b/callback_create.go index 3527858b..5271dc29 100644 --- a/callback_create.go +++ b/callback_create.go @@ -50,7 +50,7 @@ func updateTimeStampForCreateCallback(scope *Scope) { // createCallback the callback used to insert data into database func createCallback(scope *Scope) { if !scope.HasError() { - defer scope.trace(scope.db.nowFunc()) + defer scope.trace(NowFunc()) var ( columns, placeholders []string diff --git a/callback_query.go b/callback_query.go index e3b3d534..7facc42b 100644 --- a/callback_query.go +++ b/callback_query.go @@ -24,7 +24,7 @@ func queryCallback(scope *Scope) { return } - defer scope.trace(scope.db.nowFunc()) + defer scope.trace(NowFunc()) var ( isSlice, isPtr bool diff --git a/scope.go b/scope.go index 0e9dfd1c..d82cadbc 100644 --- a/scope.go +++ b/scope.go @@ -358,7 +358,7 @@ func (scope *Scope) Raw(sql string) *Scope { // Exec perform generated SQL func (scope *Scope) Exec() *Scope { - defer scope.trace(scope.db.nowFunc()) + defer scope.trace(NowFunc()) if !scope.HasError() { if result, err := scope.SQLDB().Exec(scope.SQL, scope.SQLVars...); scope.Err(err) == nil { @@ -934,7 +934,7 @@ func (scope *Scope) updatedAttrsWithValues(value interface{}) (results map[strin } func (scope *Scope) row() *sql.Row { - defer scope.trace(scope.db.nowFunc()) + defer scope.trace(NowFunc()) result := &RowQueryResult{} scope.InstanceSet("row_query_result", result) @@ -944,7 +944,7 @@ func (scope *Scope) row() *sql.Row { } func (scope *Scope) rows() (*sql.Rows, error) { - defer scope.trace(scope.db.nowFunc()) + defer scope.trace(NowFunc()) result := &RowsQueryResult{} scope.InstanceSet("row_query_result", result)