Merge branch 'master' into impr/row2bean

session.go

@@ -460,20 +460,23 @@ func (session *Session) doPrepare(sqlStr string) (stmt *core.Stmt, err error) {
 	return
 }
 
-func (session *Session) getField(dataStruct *reflect.Value, table *core.Table, col *core.Column) *reflect.Value {
+func (session *Session) getField(dataStruct *reflect.Value, key string, table *core.Table, idx int) *reflect.Value {
+	var col *core.Column
+	if col = table.GetColumnIdx(key, idx); col == nil {
+		//session.Engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq())
+		return nil
+	}
 
 	fieldValue, err := col.ValueOfV(dataStruct)
-
 	if err != nil {
 		session.Engine.logger.Error(err)
 		return nil
 	}
 
 	if !fieldValue.IsValid() || !fieldValue.CanSet() {
-		session.Engine.logger.Warnf("Table %v's column %v is not valid or cannot be set", table.Name, col.Name)
+		session.Engine.logger.Warnf("table %v's column %v is not valid or cannot set", table.Name, key)
 		return nil
 	}
-
 	return fieldValue
 }
 
@@ -507,24 +510,6 @@ func (session *Session) row2Bean(rows *core.Rows, fields []string, fieldsCount i
 	return session._row2Bean(rows, fields, fieldsCount, bean, &dataStruct, session.Statement.RefTable)
 }
 
-func (session *Session) getColumnNdx(m map[string]int, name string) int {
-
-	n := len(name)
-
-	for k := range m {
-		if len(k) != n {
-			continue
-		}
-		if strings.EqualFold(k, name) {
-			m[k] = m[k] + 1
-			return m[k]
-		}
-	}
-
-	m[name] = 0
-	return 0
-}
-
 func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount int, bean interface{}, dataStruct *reflect.Value, table *core.Table) error {
 	scanResults := make([]interface{}, fieldsCount)
 	for i := 0; i < len(fields); i++ {
@@ -549,256 +534,114 @@ func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount
 		}
 	}()
 
-	var ndx int
+	var tempMap = make(map[string]int)
-	var col *core.Column
-	var fieldValue *reflect.Value
-	var mColumnNdx = make(map[string]int)
-
 	for ii, key := range fields {
-		ndx = session.getColumnNdx(mColumnNdx, key)
+		var idx int
-
+		var ok bool
-		if col = table.GetColumnIdx(key, ndx); col == nil {
+		var lKey = strings.ToLower(key)
-			//session.Engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq())
+		if idx, ok = tempMap[lKey]; !ok {
-			continue
+			idx = 0
+		} else {
+			idx = idx + 1
 		}
+		tempMap[lKey] = idx
 
-		if fieldValue = session.getField(dataStruct, table, col); fieldValue == nil {
+		if fieldValue := session.getField(dataStruct, key, table, idx); fieldValue != nil {
-			continue
+			rawValue := reflect.Indirect(reflect.ValueOf(scanResults[ii]))
-		}
 
-		rawValue := reflect.Indirect(reflect.ValueOf(scanResults[ii]))
+			// if row is null then ignore
+			if rawValue.Interface() == nil {
+				continue
+			}
 
-		// if row is null then ignore
+			if fieldValue.CanAddr() {
-		if rawValue.Interface() == nil {
+				if structConvert, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
-			continue
+					if data, err := value2Bytes(&rawValue); err == nil {
-		}
+						structConvert.FromDB(data)
+					} else {
+						session.Engine.logger.Error(err)
+					}
+					continue
+				}
+			}
 
-		if fieldValue.CanAddr() {
+			if _, ok := fieldValue.Interface().(core.Conversion); ok {
-			if structConvert, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
 				if data, err := value2Bytes(&rawValue); err == nil {
-					structConvert.FromDB(data)
+					if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
+						fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
+					}
+					fieldValue.Interface().(core.Conversion).FromDB(data)
 				} else {
 					session.Engine.logger.Error(err)
 				}
 				continue
 			}
-		}
 
-		if _, ok := fieldValue.Interface().(core.Conversion); ok {
+			rawValueType := reflect.TypeOf(rawValue.Interface())
-			if data, err := value2Bytes(&rawValue); err == nil {
+			vv := reflect.ValueOf(rawValue.Interface())
-				if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
-					fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
-				}
-				fieldValue.Interface().(core.Conversion).FromDB(data)
-			} else {
-				session.Engine.logger.Error(err)
-			}
-			continue
-		}
 
-		rawValueType := reflect.TypeOf(rawValue.Interface())
+			fieldType := fieldValue.Type()
-		vv := reflect.ValueOf(rawValue.Interface())
+			hasAssigned := false
+			col := table.GetColumnIdx(key, idx)
 
-		fieldType := fieldValue.Type()
+			if col.SQLType.IsJson() {
-		hasAssigned := false
+				var bs []byte
-
+				if rawValueType.Kind() == reflect.String {
-		if col.SQLType.IsJson() {
+					bs = []byte(vv.String())
-			var bs []byte
+				} else if rawValueType.ConvertibleTo(core.BytesType) {
-			if rawValueType.Kind() == reflect.String {
+					bs = vv.Bytes()
-				bs = []byte(vv.String())
-			} else if rawValueType.ConvertibleTo(core.BytesType) {
-				bs = vv.Bytes()
-			} else {
-				return fmt.Errorf("unsupported database data type: %s %v", key, rawValueType.Kind())
-			}
-
-			hasAssigned = true
-
-			if len(bs) > 0 {
-				if fieldValue.CanAddr() {
-					err := json.Unmarshal(bs, fieldValue.Addr().Interface())
-					if err != nil {
-						session.Engine.logger.Error(key, err)
-						return err
-					}
 				} else {
-					x := reflect.New(fieldType)
+					return fmt.Errorf("unsupported database data type: %s %v", key, rawValueType.Kind())
-					err := json.Unmarshal(bs, x.Interface())
-					if err != nil {
-						session.Engine.logger.Error(key, err)
-						return err
-					}
-					fieldValue.Set(x.Elem())
 				}
-			}
 
-			continue
+				hasAssigned = true
-		}
 
-		switch fieldType.Kind() {
+				if len(bs) > 0 {
-		case reflect.Complex64, reflect.Complex128:
+					if fieldValue.CanAddr() {
-			// TODO: reimplement this
+						err := json.Unmarshal(bs, fieldValue.Addr().Interface())
-			var bs []byte
+						if err != nil {
-			if rawValueType.Kind() == reflect.String {
+							session.Engine.logger.Error(key, err)
-				bs = []byte(vv.String())
+							return err
-			} else if rawValueType.ConvertibleTo(core.BytesType) {
+						}
-				bs = vv.Bytes()
+					} else {
-			}
+						x := reflect.New(fieldType)
-
+						err := json.Unmarshal(bs, x.Interface())
-			hasAssigned = true
+						if err != nil {
-			if len(bs) > 0 {
+							session.Engine.logger.Error(key, err)
-				if fieldValue.CanAddr() {
+							return err
-					err := json.Unmarshal(bs, fieldValue.Addr().Interface())
+						}
-					if err != nil {
+						fieldValue.Set(x.Elem())
-						session.Engine.logger.Error(err)
-						return err
-					}
-				} else {
-					x := reflect.New(fieldType)
-					err := json.Unmarshal(bs, x.Interface())
-					if err != nil {
-						session.Engine.logger.Error(err)
-						return err
-					}
-					fieldValue.Set(x.Elem())
-				}
-			}
-		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
-						fieldValue.Set(vv)
 					}
 				}
-			}
+
-		case reflect.String:
+				continue
-			if rawValueType.Kind() == reflect.String {
-				hasAssigned = true
-				fieldValue.SetString(vv.String())
-			}
-		case reflect.Bool:
-			if rawValueType.Kind() == reflect.Bool {
-				hasAssigned = true
-				fieldValue.SetBool(vv.Bool())
-			}
-		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())
-			}
-		case reflect.Float32, reflect.Float64:
-			switch rawValueType.Kind() {
-			case reflect.Float32, reflect.Float64:
-				hasAssigned = true
-				fieldValue.SetFloat(vv.Float())
-			}
-		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())
-			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				hasAssigned = true
-				fieldValue.SetUint(uint64(vv.Int()))
 			}
 		case reflect.Struct:
 			if fieldType.ConvertibleTo(core.TimeType) {
 				if rawValueType == core.TimeType {
 					hasAssigned = true
 
-					t := vv.Convert(core.TimeType).Interface().(time.Time)
+			switch fieldType.Kind() {
-
+			case reflect.Complex64, reflect.Complex128:
-					z, _ := t.Zone()
+				// TODO: reimplement this
-					dbTZ := session.Engine.DatabaseTZ
+				var bs []byte
-					if dbTZ == nil {
-						if session.Engine.dialect.DBType() == core.SQLITE {
-							dbTZ = time.UTC
-						} else {
-							dbTZ = time.Local
-						}
-					}
-
-					// 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())
-						t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(),
-							t.Minute(), t.Second(), t.Nanosecond(), dbTZ)
-					}
-
-					// !nashtsai! convert to engine location
-					if col.TimeZone == nil {
-						t = t.In(session.Engine.TZLocation)
-					} else {
-						t = t.In(col.TimeZone)
-					}
-					fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
-
-					// t = fieldValue.Interface().(time.Time)
-					// z, _ = t.Zone()
-					// session.Engine.LogDebug("fieldValue key[%v]: %v | zone: %v | location: %+v\n", key, t, z, *t.Location())
-				} else if rawValueType == core.IntType || rawValueType == core.Int64Type ||
-					rawValueType == core.Int32Type {
-					hasAssigned = true
-					var tz *time.Location
-					if col.TimeZone == nil {
-						tz = session.Engine.TZLocation
-					} else {
-						tz = col.TimeZone
-					}
-					t := time.Unix(vv.Int(), 0).In(tz)
-					//vv = reflect.ValueOf(t)
-					fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
-				} else {
-					if d, ok := vv.Interface().([]uint8); ok {
-						hasAssigned = true
-						t, err := session.byte2Time(col, d)
-						if err != nil {
-							session.Engine.logger.Error("byte2Time error:", err.Error())
-							hasAssigned = false
-						} else {
-							fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
-						}
-					} else if d, ok := vv.Interface().(string); ok {
-						hasAssigned = true
-						t, err := session.str2Time(col, d)
-						if err != nil {
-							session.Engine.logger.Error("byte2Time error:", err.Error())
-							hasAssigned = false
-						} else {
-							fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
-						}
-					} else {
-						panic(fmt.Sprintf("rawValueType is %v, value is %v", rawValueType, vv.Interface()))
-					}
-				}
-			} else if nulVal, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
-				// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
-				hasAssigned = true
-				if err := nulVal.Scan(vv.Interface()); err != nil {
-					session.Engine.logger.Error("sql.Sanner error:", err.Error())
-					hasAssigned = false
-				}
-			} else if col.SQLType.IsJson() {
 				if rawValueType.Kind() == reflect.String {
-					hasAssigned = true
+					bs = []byte(vv.String())
-					x := reflect.New(fieldType)
+				} else if rawValueType.ConvertibleTo(core.BytesType) {
-					if len([]byte(vv.String())) > 0 {
+					bs = vv.Bytes()
-						err := json.Unmarshal([]byte(vv.String()), x.Interface())
+				}
+
+				hasAssigned = true
+				if len(bs) > 0 {
+					if fieldValue.CanAddr() {
+						err := json.Unmarshal(bs, fieldValue.Addr().Interface())
 						if err != nil {
 							session.Engine.logger.Error(err)
 							return err
 						}
-						fieldValue.Set(x.Elem())
+					} else {
-					}
+						x := reflect.New(fieldType)
-				} else if rawValueType.Kind() == reflect.Slice {
+						err := json.Unmarshal(bs, x.Interface())
-					hasAssigned = true
-					x := reflect.New(fieldType)
-					if len(vv.Bytes()) > 0 {
-						err := json.Unmarshal(vv.Bytes(), x.Interface())
 						if err != nil {
 							session.Engine.logger.Error(err)
 							return err
@@ -806,196 +649,340 @@ func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount
 						fieldValue.Set(x.Elem())
 					}
 				}
-			} else if session.Statement.UseCascade {
+			case reflect.Slice, reflect.Array:
-				table := session.Engine.autoMapType(*fieldValue)
+				switch rawValueType.Kind() {
-				if table != nil {
+				case reflect.Slice, reflect.Array:
-					hasAssigned = true
+					switch rawValueType.Elem().Kind() {
-					if len(table.PrimaryKeys) != 1 {
-						panic("unsupported non or composited primary key cascade")
-					}
-					var pk = make(core.PK, len(table.PrimaryKeys))
-
-					switch rawValueType.Kind() {
-					case reflect.Int64:
-						pk[0] = vv.Int()
-					case reflect.Int:
-						pk[0] = int(vv.Int())
-					case reflect.Int32:
-						pk[0] = int32(vv.Int())
-					case reflect.Int16:
-						pk[0] = int16(vv.Int())
-					case reflect.Int8:
-						pk[0] = int8(vv.Int())
-					case reflect.Uint64:
-						pk[0] = vv.Uint()
-					case reflect.Uint:
-						pk[0] = uint(vv.Uint())
-					case reflect.Uint32:
-						pk[0] = uint32(vv.Uint())
-					case reflect.Uint16:
-						pk[0] = uint16(vv.Uint())
 					case reflect.Uint8:
-						pk[0] = uint8(vv.Uint())
+						if fieldType.Elem().Kind() == reflect.Uint8 {
-					case reflect.String:
+							hasAssigned = true
-						pk[0] = vv.String()
+							fieldValue.Set(vv)
-					case reflect.Slice:
-						pk[0], _ = strconv.ParseInt(string(rawValue.Interface().([]byte)), 10, 64)
-					default:
-						panic(fmt.Sprintf("unsupported primary key type: %v, %v", rawValueType, fieldValue))
-					}
-
-					if !isPKZero(pk) {
-						// !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())
-						newsession := session.Engine.NewSession()
-						defer newsession.Close()
-						has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
-						if err != nil {
-							return err
-						}
-						if has {
-							//v := structInter.Elem().Interface()
-							//fieldValue.Set(reflect.ValueOf(v))
-							fieldValue.Set(structInter.Elem())
-						} else {
-							return errors.New("cascade obj is not exist")
 						}
 					}
-				} else {
-					session.Engine.logger.Error("unsupported struct type in Scan: ", fieldValue.Type().String())
 				}
-			}
+			case reflect.String:
-		case reflect.Ptr:
-			// !nashtsai! TODO merge duplicated codes above
-			//typeStr := fieldType.String()
-			switch fieldType {
-			// following types case matching ptr's native type, therefore assign ptr directly
-			case core.PtrStringType:
 				if rawValueType.Kind() == reflect.String {
-					x := vv.String()
 					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
+					fieldValue.SetString(vv.String())
 				}
-			case core.PtrBoolType:
+			case reflect.Bool:
 				if rawValueType.Kind() == reflect.Bool {
-					x := vv.Bool()
 					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
+					fieldValue.SetBool(vv.Bool())
 				}
-			case core.PtrTimeType:
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-				if rawValueType == core.PtrTimeType {
+				switch rawValueType.Kind() {
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 					hasAssigned = true
-					var x = rawValue.Interface().(time.Time)
+					fieldValue.SetInt(vv.Int())
-					fieldValue.Set(reflect.ValueOf(&x))
 				}
-			case core.PtrFloat64Type:
+			case reflect.Float32, reflect.Float64:
-				if rawValueType.Kind() == reflect.Float64 {
+				switch rawValueType.Kind() {
-					x := vv.Float()
+				case reflect.Float32, reflect.Float64:
 					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
+					fieldValue.SetFloat(vv.Float())
 				}
-			case core.PtrUint64Type:
+			case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-				if rawValueType.Kind() == reflect.Int64 {
+				switch rawValueType.Kind() {
-					var x = uint64(vv.Int())
+				case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
 					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
+					fieldValue.SetUint(vv.Uint())
-				}
+				case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			case core.PtrInt64Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					x := vv.Int()
 					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
+					fieldValue.SetUint(uint64(vv.Int()))
 				}
-			case core.PtrFloat32Type:
+			case reflect.Struct:
-				if rawValueType.Kind() == reflect.Float64 {
+				if fieldType.ConvertibleTo(core.TimeType) {
-					var x = float32(vv.Float())
+					if rawValueType == core.TimeType {
-					hasAssigned = true
+						hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.PtrIntType:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = int(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.PtrInt32Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = int32(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.PtrInt8Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = int8(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.PtrInt16Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = int16(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.PtrUintType:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = uint(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.PtrUint32Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = uint32(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.Uint8Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = uint8(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.Uint16Type:
-				if rawValueType.Kind() == reflect.Int64 {
-					var x = uint16(vv.Int())
-					hasAssigned = true
-					fieldValue.Set(reflect.ValueOf(&x))
-				}
-			case core.Complex64Type:
-				var x complex64
-				if len([]byte(vv.String())) > 0 {
-					err := json.Unmarshal([]byte(vv.String()), &x)
-					if err != nil {
-						session.Engine.logger.Error(err)
-					} else {
-						fieldValue.Set(reflect.ValueOf(&x))
-					}
-				}
-				hasAssigned = true
-			case core.Complex128Type:
-				var x complex128
-				if len([]byte(vv.String())) > 0 {
-					err := json.Unmarshal([]byte(vv.String()), &x)
-					if err != nil {
-						session.Engine.logger.Error(err)
-					} else {
-						fieldValue.Set(reflect.ValueOf(&x))
-					}
-				}
-				hasAssigned = true
-			} // switch fieldType
-			// default:
-			// 	session.Engine.LogError("unsupported type in Scan: ", reflect.TypeOf(v).String())
-		} // switch fieldType.Kind()
 
-		// !nashtsai! for value can't be assigned directly fallback to convert to []byte then back to value
+						t := vv.Convert(core.TimeType).Interface().(time.Time)
-		if !hasAssigned {
+
-			data, err := value2Bytes(&rawValue)
+						z, _ := t.Zone()
-			if err == nil {
+						dbTZ := session.Engine.DatabaseTZ
-				session.bytes2Value(col, fieldValue, data)
+						if dbTZ == nil {
-			} else {
+							if session.Engine.dialect.DBType() == core.SQLITE {
-				session.Engine.logger.Error(err.Error())
+								dbTZ = time.UTC
+							} else {
+								dbTZ = time.Local
+							}
+						}
+
+						// 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())
+							t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(),
+								t.Minute(), t.Second(), t.Nanosecond(), dbTZ)
+						}
+
+						// !nashtsai! convert to engine location
+						if col.TimeZone == nil {
+							t = t.In(session.Engine.TZLocation)
+						} else {
+							t = t.In(col.TimeZone)
+						}
+						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+
+						// t = fieldValue.Interface().(time.Time)
+						// z, _ = t.Zone()
+						// session.Engine.LogDebug("fieldValue key[%v]: %v | zone: %v | location: %+v\n", key, t, z, *t.Location())
+					} else if rawValueType == core.IntType || rawValueType == core.Int64Type ||
+						rawValueType == core.Int32Type {
+						hasAssigned = true
+						var tz *time.Location
+						if col.TimeZone == nil {
+							tz = session.Engine.TZLocation
+						} else {
+							tz = col.TimeZone
+						}
+						t := time.Unix(vv.Int(), 0).In(tz)
+						//vv = reflect.ValueOf(t)
+						fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+					} else {
+						if d, ok := vv.Interface().([]uint8); ok {
+							hasAssigned = true
+							t, err := session.byte2Time(col, d)
+							if err != nil {
+								session.Engine.logger.Error("byte2Time error:", err.Error())
+								hasAssigned = false
+							} else {
+								fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+							}
+						} else if d, ok := vv.Interface().(string); ok {
+							hasAssigned = true
+							t, err := session.str2Time(col, d)
+							if err != nil {
+								session.Engine.logger.Error("byte2Time error:", err.Error())
+								hasAssigned = false
+							} else {
+								fieldValue.Set(reflect.ValueOf(t).Convert(fieldType))
+							}
+						} else {
+							panic(fmt.Sprintf("rawValueType is %v, value is %v", rawValueType, vv.Interface()))
+						}
+					}
+				} else if nulVal, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
+					// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
+					hasAssigned = true
+					if err := nulVal.Scan(vv.Interface()); err != nil {
+						session.Engine.logger.Error("sql.Sanner error:", err.Error())
+						hasAssigned = false
+					}
+				} else if col.SQLType.IsJson() {
+					if rawValueType.Kind() == reflect.String {
+						hasAssigned = true
+						x := reflect.New(fieldType)
+						if len([]byte(vv.String())) > 0 {
+							err := json.Unmarshal([]byte(vv.String()), x.Interface())
+							if err != nil {
+								session.Engine.logger.Error(err)
+								return err
+							}
+							fieldValue.Set(x.Elem())
+						}
+					} else if rawValueType.Kind() == reflect.Slice {
+						hasAssigned = true
+						x := reflect.New(fieldType)
+						if len(vv.Bytes()) > 0 {
+							err := json.Unmarshal(vv.Bytes(), x.Interface())
+							if err != nil {
+								session.Engine.logger.Error(err)
+								return err
+							}
+							fieldValue.Set(x.Elem())
+						}
+					}
+				} else if session.Statement.UseCascade {
+					table := session.Engine.autoMapType(*fieldValue)
+					if table != nil {
+						hasAssigned = true
+						if len(table.PrimaryKeys) != 1 {
+							panic("unsupported non or composited primary key cascade")
+						}
+						var pk = make(core.PK, len(table.PrimaryKeys))
+
+						switch rawValueType.Kind() {
+						case reflect.Int64:
+							pk[0] = vv.Int()
+						case reflect.Int:
+							pk[0] = int(vv.Int())
+						case reflect.Int32:
+							pk[0] = int32(vv.Int())
+						case reflect.Int16:
+							pk[0] = int16(vv.Int())
+						case reflect.Int8:
+							pk[0] = int8(vv.Int())
+						case reflect.Uint64:
+							pk[0] = vv.Uint()
+						case reflect.Uint:
+							pk[0] = uint(vv.Uint())
+						case reflect.Uint32:
+							pk[0] = uint32(vv.Uint())
+						case reflect.Uint16:
+							pk[0] = uint16(vv.Uint())
+						case reflect.Uint8:
+							pk[0] = uint8(vv.Uint())
+						case reflect.String:
+							pk[0] = vv.String()
+						case reflect.Slice:
+							pk[0], _ = strconv.ParseInt(string(rawValue.Interface().([]byte)), 10, 64)
+						default:
+							panic(fmt.Sprintf("unsupported primary key type: %v, %v", rawValueType, fieldValue))
+						}
+
+						if !isPKZero(pk) {
+							// !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())
+							newsession := session.Engine.NewSession()
+							defer newsession.Close()
+							has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
+							if err != nil {
+								return err
+							}
+							if has {
+								//v := structInter.Elem().Interface()
+								//fieldValue.Set(reflect.ValueOf(v))
+								fieldValue.Set(structInter.Elem())
+							} else {
+								return errors.New("cascade obj is not exist")
+							}
+						}
+					} else {
+						session.Engine.logger.Error("unsupported struct type in Scan: ", fieldValue.Type().String())
+					}
+				}
+			case reflect.Ptr:
+				// !nashtsai! TODO merge duplicated codes above
+				//typeStr := fieldType.String()
+				switch fieldType {
+				// following types case matching ptr's native type, therefore assign ptr directly
+				case core.PtrStringType:
+					if rawValueType.Kind() == reflect.String {
+						x := vv.String()
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrBoolType:
+					if rawValueType.Kind() == reflect.Bool {
+						x := vv.Bool()
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrTimeType:
+					if rawValueType == core.PtrTimeType {
+						hasAssigned = true
+						var x = rawValue.Interface().(time.Time)
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrFloat64Type:
+					if rawValueType.Kind() == reflect.Float64 {
+						x := vv.Float()
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrUint64Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = uint64(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrInt64Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						x := vv.Int()
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrFloat32Type:
+					if rawValueType.Kind() == reflect.Float64 {
+						var x = float32(vv.Float())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrIntType:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = int(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrInt32Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = int32(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrInt8Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = int8(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrInt16Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = int16(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrUintType:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = uint(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.PtrUint32Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = uint32(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.Uint8Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = uint8(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.Uint16Type:
+					if rawValueType.Kind() == reflect.Int64 {
+						var x = uint16(vv.Int())
+						hasAssigned = true
+						fieldValue.Set(reflect.ValueOf(&x))
+					}
+				case core.Complex64Type:
+					var x complex64
+					if len([]byte(vv.String())) > 0 {
+						err := json.Unmarshal([]byte(vv.String()), &x)
+						if err != nil {
+							session.Engine.logger.Error(err)
+						} else {
+							fieldValue.Set(reflect.ValueOf(&x))
+						}
+					}
+					hasAssigned = true
+				case core.Complex128Type:
+					var x complex128
+					if len([]byte(vv.String())) > 0 {
+						err := json.Unmarshal([]byte(vv.String()), &x)
+						if err != nil {
+							session.Engine.logger.Error(err)
+						} else {
+							fieldValue.Set(reflect.ValueOf(&x))
+						}
+					}
+					hasAssigned = true
+				} // switch fieldType
+				// default:
+				// 	session.Engine.LogError("unsupported type in Scan: ", reflect.TypeOf(v).String())
+			} // 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 {
+					session.bytes2Value(col, fieldValue, data)
+				} else {
+					session.Engine.logger.Error(err.Error())
+				}
 			}
 		}
 	}