refactor slice2Bean

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{}, dataStruct *reflect.Value, 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,17 +465,14 @@ 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
 
@@ -514,7 +483,7 @@ 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
@@ -522,24 +491,24 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 		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())
 			}
 		}
 
-			continue
+		return nil
 	}
 
 	switch fieldType.Kind() {
@@ -557,13 +526,13 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			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())
 			}
@@ -579,7 +548,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 						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 {
@@ -644,7 +613,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 				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)
 				}
@@ -677,7 +646,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
 					}
 				} 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 {
@@ -694,7 +663,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 				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())
 				}
@@ -704,7 +673,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 				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())
 				}
@@ -712,17 +681,17 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 		} 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,12 +701,12 @@ 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")
 				}
 			}
 		}
@@ -840,7 +809,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			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))
 			}
@@ -850,7 +819,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			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))
 			}
@@ -858,16 +827,62 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 		} // switch fieldType
 	} // switch fieldType.Kind()
 
-		// !nashtsai! for value can't be assigned directly fallback to convert to []byte then back to value
+	if hasAssigned {
-		if !hasAssigned {
+		return nil
+	}
+
 	data, err := value2Bytes(&rawValue)
 	if err != nil {
-				return nil, err
+		return err
 	}
 
 	if err = session.bytes2Value(col, fieldValue, data); err != nil {
+		return err
+	}
+	return nil
+}
+
+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, dataStruct, table); err != nil {
 			return nil, err
 		}
+		if col.IsPrimaryKey {
+			pk = append(pk, scanResult)
 		}
 	}
 	return pk, nil