fix tests

session.go

@@ -450,7 +450,7 @@ func (session *Session) row2Slice(rows *core.Rows, types []*sql.ColumnType, fiel
 }
 
 // convertAssign converts an interface src to dst reflect.Value fieldValue
-func (session *Session) convertAssign(fieldValue *reflect.Value, columnName string, src interface{}, table *schemas.Table, pk *schemas.PK, idx int) error {
+func (session *Session) convertAssign(fieldValue *reflect.Value, columnName string, src interface{}, col *schemas.Column) error {
 	if fieldValue == nil {
 		return nil
 	}
@@ -532,10 +532,6 @@ func (session *Session) convertAssign(fieldValue *reflect.Value, columnName stri
 
 	rawValueType := reflect.TypeOf(rawValue.Interface())
 	vv := reflect.ValueOf(rawValue.Interface())
-	col := table.GetColumnIdx(columnName, idx)
-	if col.IsPrimaryKey {
-		*pk = append(*pk, rawValue.Interface())
-	}
 	fieldType := fieldValue.Type()
 	hasAssigned := false
 
@@ -894,13 +890,22 @@ func (session *Session) convertAssign(fieldValue *reflect.Value, columnName stri
 				// !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch
 				// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
 				// property to be fetched lazily
-				structInter := reflect.New(fieldValue.Type())
+				t := fieldValue.Type()
+				var isPtr = t.Kind() == reflect.Ptr
+				if isPtr {
+					t = t.Elem()
+				}
+				structInter := reflect.New(t)
 				has, err := session.ID(pk).NoCascade().get(structInter.Interface())
 				if err != nil {
 					return err
 				}
 				if has {
-					fieldValue.Set(structInter.Elem())
+					if isPtr {
+						fieldValue.Set(structInter)
+					} else {
+						fieldValue.Set(structInter.Elem())
+					}
 				} else {
 					return errors.New("cascade obj is not exist")
 				}
@@ -948,10 +953,15 @@ func (session *Session) slice2Bean(scanResults []interface{}, columnNames []stri
 			}
 			continue
 		}
+
+		col := table.GetColumnIdx(columnName, idx)
 		fmt.Printf("88888====== %#v \n ", scanResults[i])
-		if err := session.convertAssign(fieldValue, columnName, scanResults[i], table, &pk, idx); err != nil {
+		if err := session.convertAssign(fieldValue, columnName, scanResults[i], col); err != nil {
 			return nil, err
 		}
+		if col.IsPrimaryKey {
+			pk = append(pk, fieldValue.Interface())
+		}
 	}
 	return pk, nil
 }

session_convert.go

@@ -194,6 +194,7 @@ func (session *Session) bytes2Value(col *schemas.Column, fieldValue *reflect.Val
 				v = x
 				fieldValue.Set(reflect.ValueOf(v).Convert(fieldType))
 			} else if session.statement.UseCascade {
+				fmt.Println("====2222")
 				table, err := session.engine.tagParser.ParseWithCache(*fieldValue)
 				if err != nil {
 					return err
@@ -215,7 +216,7 @@ func (session *Session) bytes2Value(col *schemas.Column, fieldValue *reflect.Val
 					// !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch
 					// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
 					// property to be fetched lazily
-					structInter := reflect.New(fieldValue.Type())
+					structInter := reflect.New(fieldValue.Elem().Type())
 					has, err := session.ID(pk).NoCascade().get(structInter.Interface())
 					if err != nil {
 						return err
@@ -474,6 +475,7 @@ func (session *Session) bytes2Value(col *schemas.Column, fieldValue *reflect.Val
 				fieldValue.Set(reflect.ValueOf(&x))
 			default:
 				if session.statement.UseCascade {
+					fmt.Println("====1111")
 					structInter := reflect.New(fieldType.Elem())
 					table, err := session.engine.tagParser.ParseWithCache(structInter.Elem())
 					if err != nil {

session_find.go

@@ -179,12 +179,15 @@ func (session *Session) noCacheFind(table *schemas.Table, containerValue reflect
 
 	var newElemFunc func(fields []string) reflect.Value
 	elemType := containerValue.Type().Elem()
+
 	var isPointer bool
 	if elemType.Kind() == reflect.Ptr {
+		fmt.Printf("1===== %#v %#v \n", elemType, containerValue.Interface())
 		isPointer = true
 		elemType = elemType.Elem()
 	}
 	if elemType.Kind() == reflect.Ptr {
+		fmt.Printf("2===== %#v \n", elemType)
 		return errors.New("pointer to pointer is not supported")
 	}
 

session_get.go

@@ -41,6 +41,8 @@ func (session *Session) get(bean interface{}) (bool, error) {
 		return false, session.statement.LastError
 	}
 
+	fmt.Printf("========11111,,, %#v \n", bean)
+
 	beanValue := reflect.ValueOf(bean)
 	if beanValue.Kind() != reflect.Ptr {
 		return false, errors.New("needs a pointer to a value")
@@ -172,6 +174,7 @@ func (session *Session) nocacheGet(beanKind reflect.Kind, table *schemas.Table,
 	if err != nil {
 		return true, err
 	}
+
 	switch beanKind {
 	case reflect.Struct:
 		if _, ok := bean.(*time.Time); ok {