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) {
// 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 <test> 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 <test2> 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 <test2> 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 <test> 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 <test/test2>, 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 <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)
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, <test, "">
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, <test2, "">
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, <test2, "">
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, <test2, "">
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, <test, "">
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, <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.Equal(t, int64(1), n)
// 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.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)
})

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:] {
write(", ", column, " = VALUES(", column, ")")
}
// if len(table.AutoIncrement) > 0 {
// write(", ", quote(table.AutoIncrement), " = ", quote(table.AutoIncrement))
// }
}
default:
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) {
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
}