Merge

session.go

@@ -460,23 +460,20 @@ func (session *Session) doPrepare(sqlStr string) (stmt *core.Stmt, err error) {
 	return
 }
 
-func (session *Session) getField(dataStruct *reflect.Value, key string, table *core.Table, idx int) *reflect.Value {
+func (session *Session) getField(dataStruct *reflect.Value, table *core.Table, col *core.Column) *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 set", table.Name, key)
+		session.Engine.logger.Warnf("Table %v's column %v is not valid or cannot be set", table.Name, col.Name)
 		return nil
 	}
+
 	return fieldValue
 }
 
@@ -510,6 +507,24 @@ 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++ {
@@ -534,114 +549,256 @@ func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount
 		}
 	}()
 
-	var tempMap = make(map[string]int)
+	var ndx int
+	var col *core.Column
+	var fieldValue *reflect.Value
+	var mColumnNdx = make(map[string]int)
+
 	for ii, key := range fields {
-		var idx int
+		ndx = session.getColumnNdx(mColumnNdx, key)
-		var ok bool
+
-		var lKey = strings.ToLower(key)
+		if col = table.GetColumnIdx(key, ndx); col == nil {
-		if idx, ok = tempMap[lKey]; !ok {
+			//session.Engine.logger.Warnf("table %v has no column %v. %v", table.Name, key, table.ColumnsSeq())
-			idx = 0
+			continue
-		} else {
-			idx = idx + 1
 		}
-		tempMap[lKey] = idx
 
-		if fieldValue := session.getField(dataStruct, key, table, idx); fieldValue != nil {
+		if fieldValue = session.getField(dataStruct, table, col); fieldValue == nil {
-			rawValue := reflect.Indirect(reflect.ValueOf(scanResults[ii]))
+			continue
+		}
 
-			// if row is null then ignore
+		rawValue := reflect.Indirect(reflect.ValueOf(scanResults[ii]))
-			if rawValue.Interface() == nil {
-				continue
-			}
 
-			if fieldValue.CanAddr() {
+		// if row is null then ignore
-				if structConvert, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
+		if rawValue.Interface() == nil {
-					if data, err := value2Bytes(&rawValue); err == nil {
+			continue
-						structConvert.FromDB(data)
+		}
-					} else {
-						session.Engine.logger.Error(err)
-					}
-					continue
-				}
-			}
 
-			if _, ok := fieldValue.Interface().(core.Conversion); ok {
+		if fieldValue.CanAddr() {
+			if structConvert, ok := fieldValue.Addr().Interface().(core.Conversion); ok {
 				if data, err := value2Bytes(&rawValue); err == nil {
-					if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
+					structConvert.FromDB(data)
-						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())
+		if _, ok := fieldValue.Interface().(core.Conversion); ok {
-			vv := reflect.ValueOf(rawValue.Interface())
+			if data, err := value2Bytes(&rawValue); err == nil {
-
+				if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
-			fieldType := fieldValue.Type()
+					fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
-			hasAssigned := false
-			col := table.GetColumnIdx(key, idx)
-
-			if col.SQLType.IsJson() {
-				var bs []byte
-				if rawValueType.Kind() == reflect.String {
-					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())
 				}
+				fieldValue.Interface().(core.Conversion).FromDB(data)
+			} else {
+				session.Engine.logger.Error(err)
+			}
+			continue
+		}
 
-				hasAssigned = true
+		rawValueType := reflect.TypeOf(rawValue.Interface())
+		vv := reflect.ValueOf(rawValue.Interface())
 
-				if len(bs) > 0 {
+		fieldType := fieldValue.Type()
-					if fieldValue.CanAddr() {
+		hasAssigned := false
-						err := json.Unmarshal(bs, fieldValue.Addr().Interface())
+
-						if err != nil {
+		if col.SQLType.IsJson() {
-							session.Engine.logger.Error(key, err)
+			var bs []byte
-							return err
+			if rawValueType.Kind() == reflect.String {
-						}
+				bs = []byte(vv.String())
-					} else {
+			} else if rawValueType.ConvertibleTo(core.BytesType) {
-						x := reflect.New(fieldType)
+				bs = vv.Bytes()
-						err := json.Unmarshal(bs, x.Interface())
+			} else {
-						if err != nil {
+				return fmt.Errorf("unsupported database data type: %s %v", key, rawValueType.Kind())
-							session.Engine.logger.Error(key, err)
+			}
-							return err
+
-						}
+			hasAssigned = true
-						fieldValue.Set(x.Elem())
+
+			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)
+					err := json.Unmarshal(bs, x.Interface())
+					if err != nil {
+						session.Engine.logger.Error(key, err)
+						return err
+					}
+					fieldValue.Set(x.Elem())
+				}
+			}
+
+			continue
+		}
+
+		switch fieldType.Kind() {
+		case reflect.Complex64, reflect.Complex128:
+			// TODO: reimplement this
+			var bs []byte
+			if rawValueType.Kind() == reflect.String {
+				bs = []byte(vv.String())
+			} else if rawValueType.ConvertibleTo(core.BytesType) {
+				bs = vv.Bytes()
+			}
+
+			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
+					}
+				} 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)
 					}
 				}
-
+			}
-				continue
+		case reflect.String:
+			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
 
-			switch fieldType.Kind() {
+					t := vv.Convert(core.TimeType).Interface().(time.Time)
-			case reflect.Complex64, reflect.Complex128:
-				// TODO: reimplement this
-				var bs []byte
-				if rawValueType.Kind() == reflect.String {
-					bs = []byte(vv.String())
-				} else if rawValueType.ConvertibleTo(core.BytesType) {
-					bs = vv.Bytes()
-				}
 
+					z, _ := t.Zone()
+					dbTZ := session.Engine.DatabaseTZ
+					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 len(bs) > 0 {
+				if err := nulVal.Scan(vv.Interface()); err != nil {
-					if fieldValue.CanAddr() {
+					session.Engine.logger.Error("sql.Sanner error:", err.Error())
-						err := json.Unmarshal(bs, fieldValue.Addr().Interface())
+					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
 						}
-					} else {
+						fieldValue.Set(x.Elem())
-						x := reflect.New(fieldType)
+					}
-						err := json.Unmarshal(bs, x.Interface())
+				} 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
@@ -649,341 +806,197 @@ func (session *Session) _row2Bean(rows *core.Rows, fields []string, fieldsCount
 						fieldValue.Set(x.Elem())
 					}
 				}
-			case reflect.Slice, reflect.Array:
+			} else if session.Statement.UseCascade {
-				switch rawValueType.Kind() {
+				table := session.Engine.autoMapType(*fieldValue)
-				case reflect.Slice, reflect.Array:
+				if table != nil {
-					switch rawValueType.Elem().Kind() {
+					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:
-						if fieldType.Elem().Kind() == reflect.Uint8 {
+						pk[0] = uint8(vv.Uint())
-							hasAssigned = true
+					case reflect.String:
-							fieldValue.Set(vv)
+						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))
 					}
-				}
-			case reflect.String:
-				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)
+					if !isPKZero(pk) {
-
+						// !nashtsai! TODO for hasOne relationship, it's preferred to use join query for eager fetch
-						z, _ := t.Zone()
+						// however, also need to consider adding a 'lazy' attribute to xorm tag which allow hasOne
-						dbTZ := session.Engine.DatabaseTZ
+						// property to be fetched lazily
-						if dbTZ == nil {
+						structInter := reflect.New(fieldValue.Type())
-							if session.Engine.dialect.DBType() == core.SQLITE {
+						newsession := session.Engine.NewSession()
-								dbTZ = time.UTC
+						defer newsession.Close()
-							} else {
+						has, err := newsession.Id(pk).NoCascade().Get(structInter.Interface())
-								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)
+							return err
+						}
+						if has {
+							//v := structInter.Elem().Interface()
+							//fieldValue.Set(reflect.ValueOf(v))
+							fieldValue.Set(structInter.Elem())
 						} else {
-							fieldValue.Set(reflect.ValueOf(&x))
+							return errors.New("cascade obj is not exist")
 						}
 					}
-					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())
+					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())
+			}
 		}
 	}
 	return nil