fix panic when use version with uint32 type

session.go

@@ -846,11 +846,19 @@ func (session *Session) Unscoped() *Session {
 	return session
 }
 
-func (session *Session) setIntegerFieldValue(fieldValue *reflect.Value, version int64) {
+func (session *Session) freshVersionFieldValue(fieldValue *reflect.Value, isInsert bool) {
 	switch fieldValue.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		fieldValue.SetInt(version)
+		if isInsert {
+			fieldValue.SetInt(1)
+		} else {
+			fieldValue.SetInt(fieldValue.Int() + 1)
+		}
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		fieldValue.SetUint(uint64(version))
+		if isInsert {
+			fieldValue.SetUint(1)
+		} else {
+			fieldValue.SetUint(fieldValue.Uint() + 1)
+		}
 	}
 }

session_insert.go

@@ -397,7 +397,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 			if err != nil {
 				session.engine.logger.Error(err)
 			} else if verValue.IsValid() && verValue.CanSet() {
-				session.setIntegerFieldValue(verValue, 1)
+				session.freshVersionFieldValue(verValue, true)
 			}
 		}
 
@@ -440,7 +440,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 			if err != nil {
 				session.engine.logger.Error(err)
 			} else if verValue.IsValid() && verValue.CanSet() {
-				session.setIntegerFieldValue(verValue, 1)
+				session.freshVersionFieldValue(verValue, true)
 			}
 		}
 
@@ -481,7 +481,7 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 			if err != nil {
 				session.engine.logger.Error(err)
 			} else if verValue.IsValid() && verValue.CanSet() {
-				session.setIntegerFieldValue(verValue, 1)
+				session.freshVersionFieldValue(verValue, true)
 			}
 		}
 

session_update.go

@@ -116,7 +116,7 @@ func (session *Session) cacheUpdate(table *core.Table, tableName, sqlStr string,
 					} else {
 						session.engine.logger.Debug("[cacheUpdate] set bean field", bean, colName, fieldValue.Interface())
 						if col.IsVersion && session.statement.checkVersion {
-							session.setIntegerFieldValue(fieldValue, fieldValue.Int()+1)
+							session.freshVersionFieldValue(fieldValue, false)
 						} else {
 							fieldValue.Set(reflect.ValueOf(args[idx]))
 						}
@@ -357,7 +357,7 @@ func (session *Session) Update(bean interface{}, condiBean ...interface{}) (int6
 		return 0, err
 	} else if doIncVer {
 		if verValue != nil && verValue.IsValid() && verValue.CanSet() {
-			session.setIntegerFieldValue(verValue, verValue.Int()+1)
+			session.freshVersionFieldValue(verValue, false)
 		}
 	}
 

tag_version_test.go

@@ -85,7 +85,7 @@ func TestVersion1(t *testing.T) {
 	}
 	fmt.Println(newVer)
 	if newVer.Ver != 2 {
-		err = errors.New("insert error")
+		err = errors.New("update error")
 		t.Error(err)
 		panic(err)
 	}
@@ -126,3 +126,117 @@ func TestVersion2(t *testing.T) {
 		}
 	}
 }
+
+type VersionUintS struct {
+	Id      int64
+	Name    string
+	Ver     uint      `xorm:"version"`
+	Created time.Time `xorm:"created"`
+}
+
+func TestVersion3(t *testing.T) {
+	assert.NoError(t, prepareEngine())
+
+	err := testEngine.DropTables(new(VersionUintS))
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	err = testEngine.CreateTables(new(VersionUintS))
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	ver := &VersionUintS{Name: "sfsfdsfds"}
+	_, err = testEngine.Insert(ver)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+	fmt.Println(ver)
+	if ver.Ver != 1 {
+		err = errors.New("insert error")
+		t.Error(err)
+		panic(err)
+	}
+
+	newVer := new(VersionUintS)
+	has, err := testEngine.ID(ver.Id).Get(newVer)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	if !has {
+		t.Error(errors.New(fmt.Sprintf("no version id is %v", ver.Id)))
+		panic(err)
+	}
+	fmt.Println(newVer)
+	if newVer.Ver != 1 {
+		err = errors.New("insert error")
+		t.Error(err)
+		panic(err)
+	}
+
+	newVer.Name = "-------"
+	_, err = testEngine.ID(ver.Id).Update(newVer)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+	if newVer.Ver != 2 {
+		err = errors.New("update should set version back to struct")
+		t.Error(err)
+	}
+
+	newVer = new(VersionUintS)
+	has, err = testEngine.ID(ver.Id).Get(newVer)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+	fmt.Println(newVer)
+	if newVer.Ver != 2 {
+		err = errors.New("update error")
+		t.Error(err)
+		panic(err)
+	}
+}
+
+func TestVersion4(t *testing.T) {
+	assert.NoError(t, prepareEngine())
+
+	err := testEngine.DropTables(new(VersionUintS))
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	err = testEngine.CreateTables(new(VersionUintS))
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	var vers = []VersionUintS{
+		{Name: "sfsfdsfds"},
+		{Name: "xxxxx"},
+	}
+	_, err = testEngine.Insert(vers)
+	if err != nil {
+		t.Error(err)
+		panic(err)
+	}
+
+	fmt.Println(vers)
+
+	for _, v := range vers {
+		if v.Ver != 1 {
+			err := errors.New("version should be 1")
+			t.Error(err)
+			panic(err)
+		}
+	}
+}