From 1e50bd8705e0f769d58997ab636277bd20977e71 Mon Sep 17 00:00:00 2001 From: Andrew Thornton Date: Mon, 13 Mar 2023 11:03:02 +0000 Subject: [PATCH] more test changes Signed-off-by: Andrew Thornton --- integrations/session_upsert_test.go | 80 ++++++++++++++--------------- internal/statements/upsert.go | 3 -- session_upsert.go | 6 +-- 3 files changed, 43 insertions(+), 46 deletions(-) diff --git a/integrations/session_upsert_test.go b/integrations/session_upsert_test.go index 277261e3..d9bb2557 100644 --- a/integrations/session_upsert_test.go +++ b/integrations/session_upsert_test.go @@ -243,19 +243,19 @@ func TestUpsert(t *testing.T) { t.Run("NoUnique", func(t *testing.T) { // Upsert does not work if there is no unique constraint - type NoUniques struct { + type NoUniquesUpsert struct { ID int64 `xorm:"pk autoincr"` Data string } - assert.NoError(t, testEngine.Sync(new(NoUniques))) + assert.NoError(t, testEngine.Sync(new(NoUniquesUpsert))) - toInsert := &NoUniques{Data: "shouldErr"} + toInsert := &NoUniquesUpsert{Data: "shouldErr"} n, err := testEngine.Upsert(toInsert) assert.Error(t, err) assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), toInsert.ID) - toInsert = &NoUniques{Data: ""} + toInsert = &NoUniquesUpsert{Data: ""} n, err = testEngine.Upsert(toInsert) assert.Error(t, err) assert.Equal(t, int64(0), n) @@ -263,44 +263,44 @@ func TestUpsert(t *testing.T) { }) t.Run("OneUnique", func(t *testing.T) { - type OneUnique struct { + type OneUniqueUpsert struct { ID int64 `xorm:"pk autoincr"` Data string `xorm:"UNIQUE NOT NULL"` } - assert.NoError(t, testEngine.Sync2(&OneUnique{})) + assert.NoError(t, testEngine.Sync2(&OneUniqueUpsert{})) _, _ = testEngine.Exec("DELETE FROM one_unique") // Insert with the default value for the unique field - toInsert := &OneUnique{} + toInsert := &OneUniqueUpsert{} n, err := testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), toInsert.ID) // Nothing to update - toInsert = &OneUnique{} + toInsert = &OneUniqueUpsert{} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), toInsert.ID) // Successfully insert test - toInsert = &OneUnique{Data: "test"} + toInsert = &OneUniqueUpsert{Data: "test"} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), toInsert.ID) // Successfully insert test2 - toInsert = &OneUnique{Data: "test2"} + toInsert = &OneUniqueUpsert{Data: "test2"} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), toInsert.ID) // Successfully don't reinsert test or update - toInsert = &OneUnique{Data: "test"} + toInsert = &OneUniqueUpsert{Data: "test"} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(0), n) @@ -308,68 +308,68 @@ func TestUpsert(t *testing.T) { }) t.Run("MultiUnique", func(t *testing.T) { - type MultiUnique struct { + type MultiUniqueUpsert struct { ID int64 `xorm:"pk autoincr"` NotUnique string Data1 string `xorm:"UNIQUE(s) NOT NULL"` Data2 string `xorm:"UNIQUE(s) NOT NULL"` } - assert.NoError(t, testEngine.Sync2(&MultiUnique{})) + assert.NoError(t, testEngine.Sync2(&MultiUniqueUpsert{})) _, _ = testEngine.Exec("DELETE FROM multi_unique") // Insert with default values - toInsert := &MultiUnique{} + toInsert := &MultiUniqueUpsert{} n, err := testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), toInsert.ID) // successfully insert with t1 - testt1 := &MultiUnique{Data1: "test", NotUnique: "t1"} + testt1 := &MultiUniqueUpsert{Data1: "test", NotUnique: "t1"} n, err = testEngine.Upsert(testt1) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), testt1.ID) // successfully insert with t1 - test2t1 := &MultiUnique{Data1: "test2", NotUnique: "t1"} + test2t1 := &MultiUniqueUpsert{Data1: "test2", NotUnique: "t1"} n, err = testEngine.Upsert(test2t1) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), test2t1.ID) // Update to t2 - toInsert = &MultiUnique{Data1: "test2", NotUnique: "t2"} + toInsert = &MultiUniqueUpsert{Data1: "test2", NotUnique: "t2"} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) if !assert.Equal(t, int64(1), n) { - uniques := []MultiUnique{} + uniques := []MultiUniqueUpsert{} _ = testEngine.Find(&uniques) fmt.Println(uniques) } assert.Equal(t, test2t1.ID, toInsert.ID) // Update to t2 - toInsert = &MultiUnique{Data1: "test", NotUnique: "t2"} + toInsert = &MultiUniqueUpsert{Data1: "test", NotUnique: "t2"} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(1), n) if !assert.Equal(t, testt1.ID, toInsert.ID) { - uniques := []MultiUnique{} + uniques := []MultiUniqueUpsert{} _ = testEngine.Find(&uniques) fmt.Println(uniques) } // Insert , t1 - testtest2t1 := &MultiUnique{Data1: "test", Data2: "test2", NotUnique: "t1"} + testtest2t1 := &MultiUniqueUpsert{Data1: "test", Data2: "test2", NotUnique: "t1"} n, err = testEngine.Upsert(testtest2t1) assert.NoError(t, err) assert.Equal(t, int64(1), n) assert.NotEqual(t, int64(0), testtest2t1.ID) // Update to t2 - toInsert = &MultiUnique{Data1: "test", Data2: "test2", NotUnique: "t2"} + toInsert = &MultiUniqueUpsert{Data1: "test", Data2: "test2", NotUnique: "t2"} n, err = testEngine.Upsert(toInsert) assert.NoError(t, err) assert.Equal(t, int64(1), n) @@ -377,67 +377,67 @@ func TestUpsert(t *testing.T) { }) t.Run("MultiMultiUnique", func(t *testing.T) { - type MultiMultiUnique struct { + type MultiMultiUniqueUpsert struct { ID int64 `xorm:"pk autoincr"` Data0 string `xorm:"UNIQUE NOT NULL"` Data1 string `xorm:"UNIQUE(s) NOT NULL"` Data2 string `xorm:"UNIQUE(s) NOT NULL"` } - assert.NoError(t, testEngine.Sync2(&MultiMultiUnique{})) + assert.NoError(t, testEngine.Sync2(&MultiMultiUniqueUpsert{})) _, _ = testEngine.Exec("DELETE FROM multi_multi_unique") // Insert with default values - n, err := testEngine.Upsert(&MultiMultiUnique{}) + n, err := testEngine.Upsert(&MultiMultiUniqueUpsert{}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Insert with value for t1, - n, err = testEngine.Upsert(&MultiMultiUnique{Data1: "test", Data0: "t1"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data1: "test", Data0: "t1"}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Fail insert with value for t1, - n, err = testEngine.Upsert(&MultiMultiUnique{Data2: "test2", Data0: "t1"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data2: "test2", Data0: "t1"}) assert.NoError(t, err) assert.Equal(t, int64(0), n) // Insert with value for t2, - n, err = testEngine.Upsert(&MultiMultiUnique{Data2: "test2", Data0: "t2"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data2: "test2", Data0: "t2"}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Fail insert with value for t2, - n, err = testEngine.Upsert(&MultiMultiUnique{Data2: "test2", Data0: "t2"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data2: "test2", Data0: "t2"}) assert.NoError(t, err) assert.Equal(t, int64(0), n) // Fail insert with value for t2, - n, err = testEngine.Upsert(&MultiMultiUnique{Data1: "test", Data0: "t2"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data1: "test", Data0: "t2"}) assert.NoError(t, err) assert.Equal(t, int64(0), n) // Insert with value for t3, - n, err = testEngine.Upsert(&MultiMultiUnique{Data1: "test", Data2: "test2", Data0: "t3"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data1: "test", Data2: "test2", Data0: "t3"}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // fail insert with value for t2, - n, err = testEngine.Upsert(&MultiMultiUnique{Data1: "test", Data2: "test2", Data0: "t2"}) + n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data1: "test", Data2: "test2", Data0: "t2"}) assert.NoError(t, err) assert.Equal(t, int64(0), n) }) t.Run("NoPK", func(t *testing.T) { - type NoPrimaryKey struct { + type NoPrimaryKeyUpsert struct { NotID int64 Uniqued string `xorm:"UNIQUE"` } - assert.NoError(t, testEngine.Sync2(&NoPrimaryKey{})) + assert.NoError(t, testEngine.Sync2(&NoPrimaryKeyUpsert{})) _, _ = testEngine.Exec("DELETE FROM no_primary_unique") - empty := &NoPrimaryKey{} + empty := &NoPrimaryKeyUpsert{} // Insert default n, err := testEngine.Upsert(empty) @@ -445,28 +445,28 @@ func TestUpsert(t *testing.T) { assert.Equal(t, int64(1), n) // Insert with 1 - uniqued1 := &NoPrimaryKey{Uniqued: "1"} + uniqued1 := &NoPrimaryKeyUpsert{Uniqued: "1"} n, err = testEngine.Upsert(uniqued1) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Update default - n, err = testEngine.Upsert(&NoPrimaryKey{NotID: 1}) + n, err = testEngine.Upsert(&NoPrimaryKeyUpsert{NotID: 1}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Update default again - n, err = testEngine.Upsert(&NoPrimaryKey{NotID: 2}) + n, err = testEngine.Upsert(&NoPrimaryKeyUpsert{NotID: 2}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Insert with 2 - n, err = testEngine.Upsert(&NoPrimaryKey{NotID: 2, Uniqued: "2"}) + n, err = testEngine.Upsert(&NoPrimaryKeyUpsert{NotID: 2, Uniqued: "2"}) assert.NoError(t, err) assert.Equal(t, int64(1), n) // Update 2 - n, err = testEngine.Upsert(&NoPrimaryKey{NotID: 1, Uniqued: "2"}) + n, err = testEngine.Upsert(&NoPrimaryKeyUpsert{NotID: 1, Uniqued: "2"}) assert.NoError(t, err) assert.Equal(t, int64(1), n) }) diff --git a/internal/statements/upsert.go b/internal/statements/upsert.go index 725daba0..f8c3b6fb 100644 --- a/internal/statements/upsert.go +++ b/internal/statements/upsert.go @@ -76,9 +76,6 @@ func (statement *Statement) GenUpsertSQL(doUpdate bool, columns []string, args [ for _, column := range updateColumns[1:] { write(", ", column, " = VALUES(", column, ")") } - // if len(table.AutoIncrement) > 0 { - // write(", ", quote(table.AutoIncrement), " = ", quote(table.AutoIncrement)) - // } } default: return "", nil, fmt.Errorf("unimplemented") // FIXME: UPSERT diff --git a/session_upsert.go b/session_upsert.go index f562e26b..04aa7da4 100644 --- a/session_upsert.go +++ b/session_upsert.go @@ -37,7 +37,7 @@ func (session *Session) upsert(doUpdate bool, beans ...interface{}) (int64, erro switch v := bean.(type) { case map[string]interface{}: cnt, err = session.upsertMapInterface(doUpdate, v) - case []map[string]interface{}: // FIXME: handle multiple + case []map[string]interface{}: // FIXME: handle multiple? for _, m := range v { cnt, err := session.upsertMapInterface(doUpdate, m) if err != nil { @@ -47,7 +47,7 @@ func (session *Session) upsert(doUpdate bool, beans ...interface{}) (int64, erro } case map[string]string: cnt, err = session.upsertMapString(doUpdate, v) - case []map[string]string: // FIXME: handle multiple + case []map[string]string: // FIXME: handle multiple? for _, m := range v { cnt, err := session.upsertMapString(doUpdate, m) if err != nil { @@ -57,7 +57,7 @@ func (session *Session) upsert(doUpdate bool, beans ...interface{}) (int64, erro } default: sliceValue := reflect.Indirect(reflect.ValueOf(bean)) - if sliceValue.Kind() == reflect.Slice { // FIXME: handle multiple + if sliceValue.Kind() == reflect.Slice { // FIXME: handle multiple? if sliceValue.Len() <= 0 { return 0, ErrNoElementsOnSlice }