refactor slice2Bean (#1974)

as title.

Reviewed-on: https://gitea.com/xorm/xorm/pulls/1974
Co-authored-by: Lunny Xiao <xiaolunwen@gmail.com>
Co-committed-by: Lunny Xiao <xiaolunwen@gmail.com>

convert.go

@@ -238,6 +238,8 @@ func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
 func convertAssign(dest, src interface{}, originalLocation *time.Location, convertedLocation *time.Location) error {
 	// Common cases, without reflect.
 	switch s := src.(type) {
+	case *interface{}:
+		return convertAssign(dest, *s, originalLocation, convertedLocation)
 	case string:
 		switch d := dest.(type) {
 		case *string:

session.go

@@ -436,53 +436,25 @@ func (session *Session) row2Slice(rows *core.Rows, fields []string, bean interfa
 	return scanResults, nil
 }
 
-func (session *Session) slice2Bean(scanResults []interface{}, fields []string, bean interface{}, dataStruct *reflect.Value, table *schemas.Table) (schemas.PK, error) {
+func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflect.Value,
-	defer func() {
+	scanResult interface{}, table *schemas.Table) error {
-		executeAfterSet(bean, fields, scanResults)
+	rawValue := reflect.Indirect(reflect.ValueOf(scanResult))
-	}()
-
-	buildAfterProcessors(session, bean)
-
-	var tempMap = make(map[string]int)
-	var pk schemas.PK
-	for ii, key := range fields {
-		var idx int
-		var ok bool
-		var lKey = strings.ToLower(key)
-		if idx, ok = tempMap[lKey]; !ok {
-			idx = 0
-		} else {
-			idx = idx + 1
-		}
-		tempMap[lKey] = idx
-
-		fieldValue, err := session.getField(dataStruct, key, table, idx)
-		if err != nil {
-			if !strings.Contains(err.Error(), "is not valid") {
-				session.engine.logger.Warnf("%v", err)
-			}
-			continue
-		}
-		if fieldValue == nil {
-			continue
-		}
-		rawValue := reflect.Indirect(reflect.ValueOf(scanResults[ii]))
 
 	// if row is null then ignore
 	if rawValue.Interface() == nil {
-			continue
+		return nil
 	}
 
 	if fieldValue.CanAddr() {
 		if structConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok {
-				if data, err := value2Bytes(&rawValue); err == nil {
+			data, err := value2Bytes(&rawValue)
+			if err != nil {
+				return err
+			}
 			if err := structConvert.FromDB(data); err != nil {
-						return nil, err
+				return err
 			}
-				} else {
+			return nil
-					return nil, err
-				}
-				continue
 		}
 	}
 
@@ -493,19 +465,15 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			}
 			fieldValue.Interface().(convert.Conversion).FromDB(data)
 		} else {
-				return nil, err
+			return err
 		}
-			continue
+		return nil
 	}
 
 	rawValueType := reflect.TypeOf(rawValue.Interface())
 	vv := reflect.ValueOf(rawValue.Interface())
-		col := table.GetColumnIdx(key, idx)
+
-		if col.IsPrimaryKey {
-			pk = append(pk, rawValue.Interface())
-		}
 	fieldType := fieldValue.Type()
-		hasAssigned := false
 
 	if col.IsJSON {
 		var bs []byte
@@ -514,32 +482,29 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 		} else if rawValueType.ConvertibleTo(schemas.BytesType) {
 			bs = vv.Bytes()
 		} else {
-				return nil, fmt.Errorf("unsupported database data type: %s %v", key, rawValueType.Kind())
+			return fmt.Errorf("unsupported database data type: %s %v", col.Name, rawValueType.Kind())
 		}
 
-			hasAssigned = true
-
 		if len(bs) > 0 {
 			if fieldType.Kind() == reflect.String {
 				fieldValue.SetString(string(bs))
-					continue
+				return nil
 			}
 			if fieldValue.CanAddr() {
 				err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface())
 				if err != nil {
-						return nil, err
+					return err
 				}
 			} else {
 				x := reflect.New(fieldType)
 				err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface())
 				if err != nil {
-						return nil, err
+					return err
 				}
 				fieldValue.Set(x.Elem())
 			}
 		}
-
+		return nil
-			continue
 	}
 
 	switch fieldType.Kind() {
@@ -552,34 +517,33 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			bs = vv.Bytes()
 		}
 
-			hasAssigned = true
 		if len(bs) > 0 {
 			if fieldValue.CanAddr() {
 				err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface())
 				if err != nil {
-						return nil, err
+					return err
 				}
 			} else {
 				x := reflect.New(fieldType)
 				err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface())
 				if err != nil {
-						return nil, err
+					return err
 				}
 				fieldValue.Set(x.Elem())
 			}
 		}
+		return nil
 	case reflect.Slice, reflect.Array:
 		switch rawValueType.Kind() {
 		case reflect.Slice, reflect.Array:
 			switch rawValueType.Elem().Kind() {
 			case reflect.Uint8:
 				if fieldType.Elem().Kind() == reflect.Uint8 {
-						hasAssigned = true
 					if col.SQLType.IsText() {
 						x := reflect.New(fieldType)
 						err := json.DefaultJSONHandler.Unmarshal(vv.Bytes(), x.Interface())
 						if err != nil {
-								return nil, err
+							return err
 						}
 						fieldValue.Set(x.Elem())
 					} else {
@@ -595,39 +559,40 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 							}
 						}
 					}
+					return nil
 				}
 			}
 		}
 	case reflect.String:
 		if rawValueType.Kind() == reflect.String {
-				hasAssigned = true
 			fieldValue.SetString(vv.String())
+			return nil
 		}
 	case reflect.Bool:
 		if rawValueType.Kind() == reflect.Bool {
-				hasAssigned = true
 			fieldValue.SetBool(vv.Bool())
+			return nil
 		}
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		switch rawValueType.Kind() {
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				hasAssigned = true
 			fieldValue.SetInt(vv.Int())
+			return nil
 		}
 	case reflect.Float32, reflect.Float64:
 		switch rawValueType.Kind() {
 		case reflect.Float32, reflect.Float64:
-				hasAssigned = true
 			fieldValue.SetFloat(vv.Float())
+			return nil
 		}
 	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
 		switch rawValueType.Kind() {
 		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-				hasAssigned = true
 			fieldValue.SetUint(vv.Uint())
+			return nil
 		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				hasAssigned = true
 			fieldValue.SetUint(uint64(vv.Int()))
+			return nil
 		}
 	case reflect.Struct:
 		if fieldType.ConvertibleTo(schemas.TimeType) {
@@ -637,92 +602,87 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			}
 
 			if rawValueType == schemas.TimeType {
-					hasAssigned = true
-
 				t := vv.Convert(schemas.TimeType).Interface().(time.Time)
 
 				z, _ := t.Zone()
 				// set new location if database don't save timezone or give an incorrect timezone
 				if len(z) == 0 || t.Year() == 0 || t.Location().String() != dbTZ.String() { // !nashtsai! HACK tmp work around for lib/pq doesn't properly time with location
-						session.engine.logger.Debugf("empty zone key[%v] : %v | zone: %v | location: %+v\n", key, t, z, *t.Location())
+					session.engine.logger.Debugf("empty zone key[%v] : %v | zone: %v | location: %+v\n", col.Name, t, z, *t.Location())
 					t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(),
 						t.Minute(), t.Second(), t.Nanosecond(), dbTZ)
 				}
 
 				t = t.In(session.engine.TZLocation)
 				fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+				return nil
 			} else if rawValueType == schemas.IntType || rawValueType == schemas.Int64Type ||
 				rawValueType == schemas.Int32Type {
-					hasAssigned = true
-
 				t := time.Unix(vv.Int(), 0).In(session.engine.TZLocation)
 				fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+				return nil
 			} else {
 				if d, ok := vv.Interface().([]uint8); ok {
-						hasAssigned = true
 					t, err := session.byte2Time(col, d)
 					if err != nil {
 						session.engine.logger.Errorf("byte2Time error: %v", err)
-							hasAssigned = false
 					} else {
 						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+						return nil
 					}
+
 				} else if d, ok := vv.Interface().(string); ok {
-						hasAssigned = true
 					t, err := session.str2Time(col, d)
 					if err != nil {
 						session.engine.logger.Errorf("byte2Time error: %v", err)
-							hasAssigned = false
 					} else {
 						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+						return nil
 					}
 				} else {
-						return nil, fmt.Errorf("rawValueType is %v, value is %v", rawValueType, vv.Interface())
+					return fmt.Errorf("rawValueType is %v, value is %v", rawValueType, vv.Interface())
 				}
 			}
 		} else if nulVal, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
-				// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
+			err := nulVal.Scan(vv.Interface())
-				hasAssigned = true
+			if err == nil {
-				if err := nulVal.Scan(vv.Interface()); err != nil {
+				return nil
-					session.engine.logger.Errorf("sql.Sanner error: %v", err)
-					hasAssigned = false
 			}
+			session.engine.logger.Errorf("sql.Sanner error: %v", err)
 		} else if col.IsJSON {
 			if rawValueType.Kind() == reflect.String {
-					hasAssigned = true
 				x := reflect.New(fieldType)
 				if len([]byte(vv.String())) > 0 {
 					err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), x.Interface())
 					if err != nil {
-							return nil, err
+						return err
 					}
 					fieldValue.Set(x.Elem())
 				}
+				return nil
 			} else if rawValueType.Kind() == reflect.Slice {
-					hasAssigned = true
 				x := reflect.New(fieldType)
 				if len(vv.Bytes()) > 0 {
 					err := json.DefaultJSONHandler.Unmarshal(vv.Bytes(), x.Interface())
 					if err != nil {
-							return nil, err
+						return err
 					}
 					fieldValue.Set(x.Elem())
 				}
+				return nil
 			}
 		} else if session.statement.UseCascade {
 			table, err := session.engine.tagParser.ParseWithCache(*fieldValue)
 			if err != nil {
-					return nil, err
+				return err
 			}
 
-				hasAssigned = true
 			if len(table.PrimaryKeys) != 1 {
-					return nil, errors.New("unsupported non or composited primary key cascade")
+				return errors.New("unsupported non or composited primary key cascade")
 			}
 			var pk = make(schemas.PK, len(table.PrimaryKeys))
 			pk[0], err = asKind(vv, rawValueType)
 			if err != nil {
-					return nil, err
+				return err
 			}
 
 			if !pk.IsZero() {
@@ -732,14 +692,15 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 				structInter := reflect.New(fieldValue.Type())
 				has, err := session.ID(pk).NoCascade().get(structInter.Interface())
 				if err != nil {
-						return nil, err
+					return err
 				}
 				if has {
 					fieldValue.Set(structInter.Elem())
 				} else {
-						return nil, errors.New("cascade obj is not exist")
+					return errors.New("cascade obj is not exist")
 				}
 			}
+			return nil
 		}
 	case reflect.Ptr:
 		// !nashtsai! TODO merge duplicated codes above
@@ -748,126 +709,165 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 		case schemas.PtrStringType:
 			if rawValueType.Kind() == reflect.String {
 				x := vv.String()
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrBoolType:
 			if rawValueType.Kind() == reflect.Bool {
 				x := vv.Bool()
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrTimeType:
 			if rawValueType == schemas.PtrTimeType {
-					hasAssigned = true
 				var x = rawValue.Interface().(time.Time)
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrFloat64Type:
 			if rawValueType.Kind() == reflect.Float64 {
 				x := vv.Float()
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrUint64Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = uint64(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrInt64Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				x := vv.Int()
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrFloat32Type:
 			if rawValueType.Kind() == reflect.Float64 {
 				var x = float32(vv.Float())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrIntType:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = int(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrInt32Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = int32(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrInt8Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = int8(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrInt16Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = int16(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrUintType:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = uint(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.PtrUint32Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = uint32(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.Uint8Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = uint8(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.Uint16Type:
 			if rawValueType.Kind() == reflect.Int64 {
 				var x = uint16(vv.Int())
-					hasAssigned = true
 				fieldValue.Set(reflect.ValueOf(&x))
+				return nil
 			}
 		case schemas.Complex64Type:
 			var x complex64
 			if len([]byte(vv.String())) > 0 {
 				err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), &x)
 				if err != nil {
-						return nil, err
+					return err
 				}
 				fieldValue.Set(reflect.ValueOf(&x))
 			}
-				hasAssigned = true
+			return nil
 		case schemas.Complex128Type:
 			var x complex128
 			if len([]byte(vv.String())) > 0 {
 				err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), &x)
 				if err != nil {
-						return nil, err
+					return err
 				}
 				fieldValue.Set(reflect.ValueOf(&x))
 			}
-				hasAssigned = true
+			return nil
 		} // switch fieldType
 	} // switch fieldType.Kind()
 
-		// !nashtsai! for value can't be assigned directly fallback to convert to []byte then back to value
-		if !hasAssigned {
 	data, err := value2Bytes(&rawValue)
 	if err != nil {
-				return nil, err
+		return err
 	}
 
-			if err = session.bytes2Value(col, fieldValue, data); err != nil {
+	return session.bytes2Value(col, fieldValue, data)
+}
+
+func (session *Session) slice2Bean(scanResults []interface{}, fields []string, bean interface{}, dataStruct *reflect.Value, table *schemas.Table) (schemas.PK, error) {
+	defer func() {
+		executeAfterSet(bean, fields, scanResults)
+	}()
+
+	buildAfterProcessors(session, bean)
+
+	var tempMap = make(map[string]int)
+	var pk schemas.PK
+	for ii, key := range fields {
+		var idx int
+		var lKey = strings.ToLower(key)
+		var ok bool
+
+		if idx, ok = tempMap[lKey]; !ok {
+			idx = 0
+		} else {
+			idx = idx + 1
+		}
+
+		tempMap[lKey] = idx
+		col := table.GetColumnIdx(key, idx)
+
+		var scanResult = scanResults[ii]
+
+		fieldValue, err := session.getField(dataStruct, key, table, idx)
+		if err != nil {
+			if !strings.Contains(err.Error(), "is not valid") {
+				session.engine.logger.Warnf("%v", err)
+			}
+			continue
+		}
+		if fieldValue == nil {
+			continue
+		}
+
+		if err := session.convertBeanField(col, fieldValue, scanResult, table); err != nil {
 			return nil, err
 		}
+		if col.IsPrimaryKey {
+			pk = append(pk, scanResult)
 		}
 	}
 	return pk, nil