HiPoweredDev
/
xorm
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

more test changes 

Signed-off-by: Andrew Thornton <art27@cantab.net>
This commit is contained in:
Andrew Thornton 2023-03-13 11:03:02 +00:00
parent 3708430ebf
commit 1e50bd8705
No known key found for this signature in database
GPG Key ID: 3CDE74631F13A748
3 changed files with 43 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
integrations/session_upsert_test.go
View File

@ -243,19 +243,19 @@ func TestUpsert(t *testing.T) {
t.Run("NoUnique", func(t *testing.T) { t.Run("NoUnique", func(t *testing.T) {
// Upsert does not work if there is no unique constraint // Upsert does not work if there is no unique constraint
type NoUniques struct { type NoUniquesUpsert struct {
ID int64 `xorm:"pk autoincr"` ID int64 `xorm:"pk autoincr"`
Data string 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) n, err := testEngine.Upsert(toInsert)
assert.Error(t, err) assert.Error(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
assert.Equal(t, int64(0), toInsert.ID) assert.Equal(t, int64(0), toInsert.ID)
toInsert = &NoUniques{Data: ""} toInsert = &NoUniquesUpsert{Data: ""}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.Error(t, err) assert.Error(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
@ -263,44 +263,44 @@ func TestUpsert(t *testing.T) {
}) })
t.Run("OneUnique", func(t *testing.T) { t.Run("OneUnique", func(t *testing.T) {
type OneUnique struct { type OneUniqueUpsert struct {
ID int64 `xorm:"pk autoincr"` ID int64 `xorm:"pk autoincr"`
Data string `xorm:"UNIQUE NOT NULL"` Data string `xorm:"UNIQUE NOT NULL"`
} }
assert.NoError(t, testEngine.Sync2(&OneUnique{})) assert.NoError(t, testEngine.Sync2(&OneUniqueUpsert{}))
_, _ = testEngine.Exec("DELETE FROM one_unique") _, _ = testEngine.Exec("DELETE FROM one_unique")
// Insert with the default value for the unique field // Insert with the default value for the unique field
toInsert := &OneUnique{} toInsert := &OneUniqueUpsert{}
n, err := testEngine.Upsert(toInsert) n, err := testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), toInsert.ID) assert.NotEqual(t, int64(0), toInsert.ID)
// Nothing to update // Nothing to update
toInsert = &OneUnique{} toInsert = &OneUniqueUpsert{}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
assert.Equal(t, int64(0), toInsert.ID) assert.Equal(t, int64(0), toInsert.ID)
// Successfully insert test // Successfully insert test
toInsert = &OneUnique{Data: "test"} toInsert = &OneUniqueUpsert{Data: "test"}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), toInsert.ID) assert.NotEqual(t, int64(0), toInsert.ID)
// Successfully insert test2 // Successfully insert test2
toInsert = &OneUnique{Data: "test2"} toInsert = &OneUniqueUpsert{Data: "test2"}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), toInsert.ID) assert.NotEqual(t, int64(0), toInsert.ID)
// Successfully don't reinsert test or update // Successfully don't reinsert test or update
toInsert = &OneUnique{Data: "test"} toInsert = &OneUniqueUpsert{Data: "test"}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
@ -308,68 +308,68 @@ func TestUpsert(t *testing.T) {
}) })
t.Run("MultiUnique", func(t *testing.T) { t.Run("MultiUnique", func(t *testing.T) {
type MultiUnique struct { type MultiUniqueUpsert struct {
ID int64 `xorm:"pk autoincr"` ID int64 `xorm:"pk autoincr"`
NotUnique string NotUnique string
Data1 string `xorm:"UNIQUE(s) NOT NULL"` Data1 string `xorm:"UNIQUE(s) NOT NULL"`
Data2 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") _, _ = testEngine.Exec("DELETE FROM multi_unique")
// Insert with default values // Insert with default values
toInsert := &MultiUnique{} toInsert := &MultiUniqueUpsert{}
n, err := testEngine.Upsert(toInsert) n, err := testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), toInsert.ID) assert.NotEqual(t, int64(0), toInsert.ID)
// successfully insert <test> with t1 // successfully insert <test> with t1
testt1 := &MultiUnique{Data1: "test", NotUnique: "t1"} testt1 := &MultiUniqueUpsert{Data1: "test", NotUnique: "t1"}
n, err = testEngine.Upsert(testt1) n, err = testEngine.Upsert(testt1)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), testt1.ID) assert.NotEqual(t, int64(0), testt1.ID)
// successfully insert <test2> with t1 // successfully insert <test2> with t1
test2t1 := &MultiUnique{Data1: "test2", NotUnique: "t1"} test2t1 := &MultiUniqueUpsert{Data1: "test2", NotUnique: "t1"}
n, err = testEngine.Upsert(test2t1) n, err = testEngine.Upsert(test2t1)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), test2t1.ID) assert.NotEqual(t, int64(0), test2t1.ID)
// Update <test2> to t2 // Update <test2> to t2
toInsert = &MultiUnique{Data1: "test2", NotUnique: "t2"} toInsert = &MultiUniqueUpsert{Data1: "test2", NotUnique: "t2"}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
if !assert.Equal(t, int64(1), n) { if !assert.Equal(t, int64(1), n) {
uniques := []MultiUnique{} uniques := []MultiUniqueUpsert{}
_ = testEngine.Find(&uniques) _ = testEngine.Find(&uniques)
fmt.Println(uniques) fmt.Println(uniques)
} }
assert.Equal(t, test2t1.ID, toInsert.ID) assert.Equal(t, test2t1.ID, toInsert.ID)
// Update <test> to t2 // Update <test> to t2
toInsert = &MultiUnique{Data1: "test", NotUnique: "t2"} toInsert = &MultiUniqueUpsert{Data1: "test", NotUnique: "t2"}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
if !assert.Equal(t, testt1.ID, toInsert.ID) { if !assert.Equal(t, testt1.ID, toInsert.ID) {
uniques := []MultiUnique{} uniques := []MultiUniqueUpsert{}
_ = testEngine.Find(&uniques) _ = testEngine.Find(&uniques)
fmt.Println(uniques) fmt.Println(uniques)
} }
// Insert <test/test2>, t1 // Insert <test/test2>, t1
testtest2t1 := &MultiUnique{Data1: "test", Data2: "test2", NotUnique: "t1"} testtest2t1 := &MultiUniqueUpsert{Data1: "test", Data2: "test2", NotUnique: "t1"}
n, err = testEngine.Upsert(testtest2t1) n, err = testEngine.Upsert(testtest2t1)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
assert.NotEqual(t, int64(0), testtest2t1.ID) assert.NotEqual(t, int64(0), testtest2t1.ID)
// Update <test/test2> to t2 // Update <test/test2> to t2
toInsert = &MultiUnique{Data1: "test", Data2: "test2", NotUnique: "t2"} toInsert = &MultiUniqueUpsert{Data1: "test", Data2: "test2", NotUnique: "t2"}
n, err = testEngine.Upsert(toInsert) n, err = testEngine.Upsert(toInsert)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
@ -377,67 +377,67 @@ func TestUpsert(t *testing.T) {
}) })
t.Run("MultiMultiUnique", func(t *testing.T) { t.Run("MultiMultiUnique", func(t *testing.T) {
type MultiMultiUnique struct { type MultiMultiUniqueUpsert struct {
ID int64 `xorm:"pk autoincr"` ID int64 `xorm:"pk autoincr"`
Data0 string `xorm:"UNIQUE NOT NULL"` Data0 string `xorm:"UNIQUE NOT NULL"`
Data1 string `xorm:"UNIQUE(s) NOT NULL"` Data1 string `xorm:"UNIQUE(s) NOT NULL"`
Data2 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") _, _ = testEngine.Exec("DELETE FROM multi_multi_unique")
// Insert with default values // Insert with default values
n, err := testEngine.Upsert(&MultiMultiUnique{}) n, err := testEngine.Upsert(&MultiMultiUniqueUpsert{})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Insert with value for t1, <test, ""> // Insert with value for t1, <test, "">
n, err = testEngine.Upsert(&MultiMultiUnique{Data1: "test", Data0: "t1"}) n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data1: "test", Data0: "t1"})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Fail insert with value for t1, <test2, ""> // Fail insert with value for t1, <test2, "">
n, err = testEngine.Upsert(&MultiMultiUnique{Data2: "test2", Data0: "t1"}) n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data2: "test2", Data0: "t1"})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
// Insert with value for t2, <test2, ""> // Insert with value for t2, <test2, "">
n, err = testEngine.Upsert(&MultiMultiUnique{Data2: "test2", Data0: "t2"}) n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data2: "test2", Data0: "t2"})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Fail insert with value for t2, <test2, ""> // Fail insert with value for t2, <test2, "">
n, err = testEngine.Upsert(&MultiMultiUnique{Data2: "test2", Data0: "t2"}) n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data2: "test2", Data0: "t2"})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
// Fail insert with value for t2, <test, ""> // Fail insert with value for t2, <test, "">
n, err = testEngine.Upsert(&MultiMultiUnique{Data1: "test", Data0: "t2"}) n, err = testEngine.Upsert(&MultiMultiUniqueUpsert{Data1: "test", Data0: "t2"})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
// Insert with value for t3, <test, test2> // Insert with value for t3, <test, test2>
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.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// fail insert with value for t2, <test, test2> // fail insert with value for t2, <test, test2>
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.NoError(t, err)
assert.Equal(t, int64(0), n) assert.Equal(t, int64(0), n)
}) })
t.Run("NoPK", func(t *testing.T) { t.Run("NoPK", func(t *testing.T) {
type NoPrimaryKey struct { type NoPrimaryKeyUpsert struct {
NotID int64 NotID int64
Uniqued string `xorm:"UNIQUE"` Uniqued string `xorm:"UNIQUE"`
} }
assert.NoError(t, testEngine.Sync2(&NoPrimaryKey{})) assert.NoError(t, testEngine.Sync2(&NoPrimaryKeyUpsert{}))
_, _ = testEngine.Exec("DELETE FROM no_primary_unique") _, _ = testEngine.Exec("DELETE FROM no_primary_unique")
empty := &NoPrimaryKey{} empty := &NoPrimaryKeyUpsert{}
// Insert default // Insert default
n, err := testEngine.Upsert(empty) n, err := testEngine.Upsert(empty)
@ -445,28 +445,28 @@ func TestUpsert(t *testing.T) {
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Insert with 1 // Insert with 1
uniqued1 := &NoPrimaryKey{Uniqued: "1"} uniqued1 := &NoPrimaryKeyUpsert{Uniqued: "1"}
n, err = testEngine.Upsert(uniqued1) n, err = testEngine.Upsert(uniqued1)
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Update default // Update default
n, err = testEngine.Upsert(&NoPrimaryKey{NotID: 1}) n, err = testEngine.Upsert(&NoPrimaryKeyUpsert{NotID: 1})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Update default again // Update default again
n, err = testEngine.Upsert(&NoPrimaryKey{NotID: 2}) n, err = testEngine.Upsert(&NoPrimaryKeyUpsert{NotID: 2})
assert.NoError(t, err) assert.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Insert with 2 // 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.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
// Update 2 // 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.NoError(t, err)
assert.Equal(t, int64(1), n) assert.Equal(t, int64(1), n)
}) })

3
internal/statements/upsert.go
View File

@ -76,9 +76,6 @@ func (statement *Statement) GenUpsertSQL(doUpdate bool, columns []string, args [
for _, column := range updateColumns[1:] { for _, column := range updateColumns[1:] {
write(", ", column, " = VALUES(", column, ")") write(", ", column, " = VALUES(", column, ")")
} }
// if len(table.AutoIncrement) > 0 {
// write(", ", quote(table.AutoIncrement), " = ", quote(table.AutoIncrement))
// }
} }
default: default:
return "", nil, fmt.Errorf("unimplemented") // FIXME: UPSERT return "", nil, fmt.Errorf("unimplemented") // FIXME: UPSERT

6
session_upsert.go
View File

@ -37,7 +37,7 @@ func (session *Session) upsert(doUpdate bool, beans ...interface{}) (int64, erro
switch v := bean.(type) { switch v := bean.(type) {
case map[string]interface{}: case map[string]interface{}:
cnt, err = session.upsertMapInterface(doUpdate, v) cnt, err = session.upsertMapInterface(doUpdate, v)
case []map[string]interface{}: // FIXME: handle multiple case []map[string]interface{}: // FIXME: handle multiple?
for _, m := range v { for _, m := range v {
cnt, err := session.upsertMapInterface(doUpdate, m) cnt, err := session.upsertMapInterface(doUpdate, m)
if err != nil { if err != nil {
@ -47,7 +47,7 @@ func (session *Session) upsert(doUpdate bool, beans ...interface{}) (int64, erro
} }
case map[string]string: case map[string]string:
cnt, err = session.upsertMapString(doUpdate, v) cnt, err = session.upsertMapString(doUpdate, v)
case []map[string]string: // FIXME: handle multiple case []map[string]string: // FIXME: handle multiple?
for _, m := range v { for _, m := range v {
cnt, err := session.upsertMapString(doUpdate, m) cnt, err := session.upsertMapString(doUpdate, m)
if err != nil { if err != nil {
@ -57,7 +57,7 @@ func (session *Session) upsert(doUpdate bool, beans ...interface{}) (int64, erro
} }
default: default:
sliceValue := reflect.Indirect(reflect.ValueOf(bean)) 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 { if sliceValue.Len() <= 0 {
return 0, ErrNoElementsOnSlice return 0, ErrNoElementsOnSlice
} }