Refactor asbytes

convert.go

@@ -7,6 +7,7 @@ package xorm
 import (
 	"database/sql"
 	"database/sql/driver"
+	"encoding/json"
 	"errors"
 	"fmt"
 	"math/big"
@@ -285,23 +286,36 @@ func asBigFloat(src interface{}) (*big.Float, error) {
 	return nil, fmt.Errorf("unsupported value %T as big.Float", src)
 }
 
-func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
+func asBytes(src interface{}) ([]byte, bool) {
+	switch t := src.(type) {
+	case []byte:
+		return t, true
+	case *sql.NullString:
+		if !t.Valid {
+			return nil, true
+		}
+		return []byte(t.String), true
+	case *sql.RawBytes:
+		return *t, true
+	}
+
+	rv := reflect.ValueOf(src)
+
 	switch rv.Kind() {
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return strconv.AppendInt(buf, rv.Int(), 10), true
+		return strconv.AppendInt(nil, rv.Int(), 10), true
 	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		return strconv.AppendUint(buf, rv.Uint(), 10), true
+		return strconv.AppendUint(nil, rv.Uint(), 10), true
 	case reflect.Float32:
-		return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 32), true
+		return strconv.AppendFloat(nil, rv.Float(), 'g', -1, 32), true
 	case reflect.Float64:
-		return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 64), true
+		return strconv.AppendFloat(nil, rv.Float(), 'g', -1, 64), true
 	case reflect.Bool:
-		return strconv.AppendBool(buf, rv.Bool()), true
+		return strconv.AppendBool(nil, rv.Bool()), true
 	case reflect.String:
-		s := rv.String()
+		return []byte(rv.String()), true
-		return append(buf, s...), true
 	}
-	return
+	return nil, false
 }
 
 // convertAssign copies to dest the value in src, converting it if possible.
@@ -559,8 +573,7 @@ func convertAssign(dest, src interface{}, originalLocation *time.Location, conve
 			return nil
 		}
 	case *[]byte:
-		sv = reflect.ValueOf(src)
+		if b, ok := asBytes(src); ok {
-		if b, ok := asBytes(nil, sv); ok {
 			*d = b
 			return nil
 		}
@@ -578,41 +591,21 @@ func convertAssign(dest, src interface{}, originalLocation *time.Location, conve
 	return convertAssignV(reflect.ValueOf(dest), src, originalLocation, convertedLocation)
 }
 
-func convertAssignV(dpv reflect.Value, src interface{}, originalLocation, convertedLocation *time.Location) error {
+func convertAssignV(dv reflect.Value, src interface{}, originalLocation, convertedLocation *time.Location) error {
-	if dpv.Kind() != reflect.Ptr {
+	if src == nil {
-		return errors.New("destination not a pointer")
-	}
-	if dpv.IsNil() {
-		return errNilPtr
-	}
-
-	var sv = reflect.ValueOf(src)
-
-	dv := reflect.Indirect(dpv)
-	if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
-		switch b := src.(type) {
-		case []byte:
-			dv.Set(reflect.ValueOf(cloneBytes(b)))
-		default:
-			dv.Set(sv)
-		}
 		return nil
 	}
 
-	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
+	if dv.Type().Implements(scannerType) {
-		dv.Set(sv.Convert(dv.Type()))
+		return dv.Interface().(sql.Scanner).Scan(src)
-		return nil
 	}
 
 	switch dv.Kind() {
 	case reflect.Ptr:
-		if src == nil {
+		if dv.IsNil() {
-			dv.Set(reflect.Zero(dv.Type()))
-			return nil
-		}
-
 			dv.Set(reflect.New(dv.Type().Elem()))
-		return convertAssign(dv.Interface(), src, originalLocation, convertedLocation)
+		}
+		return convertAssignV(dv.Elem(), src, originalLocation, convertedLocation)
 	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
 		i64, err := asInt64(src)
 		if err != nil {
@@ -640,9 +633,28 @@ func convertAssignV(dpv reflect.Value, src interface{}, originalLocation, conver
 	case reflect.String:
 		dv.SetString(asString(src))
 		return nil
+	case reflect.Bool:
+		b, err := asBool(src)
+		if err != nil {
+			return err
+		}
+		dv.SetBool(b)
+		return nil
+	case reflect.Slice, reflect.Map, reflect.Struct, reflect.Array:
+		data, ok := asBytes(src)
+		if !ok {
+			return fmt.Errorf("onvertAssignV: src cannot be as bytes %#v", src)
+		}
+		if data == nil {
+			return nil
+		}
+		if dv.Kind() != reflect.Ptr {
+			dv = dv.Addr()
+		}
+		return json.Unmarshal(data, dv.Interface())
+	default:
+		return fmt.Errorf("convertAssignV: unsupported Scan, storing driver.Value type %T into type %T", src, dv.Interface())
 	}
-
-	return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dpv.Interface())
 }
 
 func asKind(vv reflect.Value, tp reflect.Type) (interface{}, error) {
@@ -682,16 +694,43 @@ func asKind(vv reflect.Value, tp reflect.Type) (interface{}, error) {
 	return nil, fmt.Errorf("unsupported primary key type: %v, %v", tp, vv)
 }
 
-func asBool(bs []byte) (bool, error) {
+func asBool(src interface{}) (bool, error) {
-	if len(bs) == 0 {
+	switch v := src.(type) {
+	case bool:
+		return v, nil
+	case *bool:
+		return *v, nil
+	case *sql.NullBool:
+		return v.Bool, nil
+	case int64:
+		return v > 0, nil
+	case int:
+		return v > 0, nil
+	case int8:
+		return v > 0, nil
+	case int16:
+		return v > 0, nil
+	case int32:
+		return v > 0, nil
+	case []byte:
+		if len(v) == 0 {
 			return false, nil
 		}
-	if bs[0] == 0x00 {
+		if v[0] == 0x00 {
 			return false, nil
-	} else if bs[0] == 0x01 {
+		} else if v[0] == 0x01 {
 			return true, nil
 		}
-	return strconv.ParseBool(string(bs))
+		return strconv.ParseBool(string(v))
+	case string:
+		return strconv.ParseBool(v)
+	case *sql.NullInt64:
+		return v.Int64 > 0, nil
+	case *sql.NullInt32:
+		return v.Int32 > 0, nil
+	default:
+		return false, fmt.Errorf("unknow type %T as bool", src)
+	}
 }
 
 // str2PK convert string value to primary key value according to tp

integrations/types_null_test.go

@@ -7,7 +7,6 @@ package integrations
 import (
 	"database/sql"
 	"database/sql/driver"
-	"errors"
 	"fmt"
 	"strconv"
 	"strings"
@@ -42,15 +41,22 @@ func (m *CustomStruct) Scan(value interface{}) error {
 		return nil
 	}
 
-	if s, ok := value.([]byte); ok {
+	var s string
-		seps := strings.Split(string(s), "/")
+	switch t := value.(type) {
+	case string:
+		s = t
+	case []byte:
+		s = string(t)
+	}
+	if len(s) > 0 {
+		seps := strings.Split(s, "/")
 		m.Year, _ = strconv.Atoi(seps[0])
 		m.Month, _ = strconv.Atoi(seps[1])
 		m.Day, _ = strconv.Atoi(seps[2])
 		return nil
 	}
 
-	return errors.New("scan data not fit []byte")
+	return fmt.Errorf("scan data %#v not fit []byte", value)
 }
 
 func (m CustomStruct) Value() (driver.Value, error) {

session.go

@@ -454,27 +454,28 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 
 	if fieldValue.CanAddr() {
 		if structConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok {
-			data, err := value2Bytes(&rawValue)
+			data, ok := asBytes(scanResult)
-			if err != nil {
+			if !ok {
-				return err
+				return fmt.Errorf("cannot convert %#v as bytes", scanResult)
 			}
-			if err := structConvert.FromDB(data); err != nil {
+			return structConvert.FromDB(data)
-				return err
-			}
-			return nil
 		}
 	}
 
-	if _, ok := fieldValue.Interface().(convert.Conversion); ok {
+	if structConvert, ok := fieldValue.Interface().(convert.Conversion); ok {
-		if data, err := value2Bytes(&rawValue); err == nil {
+		data, ok := asBytes(scanResult)
+		if !ok {
+			return fmt.Errorf("cannot convert %#v as bytes", scanResult)
+		}
+		if data == nil {
+			return nil
+		}
+
 		if fieldValue.Kind() == reflect.Ptr && fieldValue.IsNil() {
 			fieldValue.Set(reflect.New(fieldValue.Type().Elem()))
+			return fieldValue.Interface().(convert.Conversion).FromDB(data)
 		}
-			fieldValue.Interface().(convert.Conversion).FromDB(data)
+		return structConvert.FromDB(data)
-		} else {
-			return err
-		}
-		return nil
 	}
 
 	rawValueType := reflect.TypeOf(rawValue.Interface())
@@ -733,12 +734,7 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 		}
 	} // switch fieldType.Kind()
 
-	data, err := value2Bytes(&rawValue)
+	return convertAssignV(fieldValue.Addr(), scanResult, session.engine.DatabaseTZ, session.engine.TZLocation)
-	if err != nil {
-		return err
-	}
-
-	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) {

session_convert.go

@@ -5,16 +5,11 @@
 package xorm
 
 import (
-	"database/sql"
-	"errors"
 	"fmt"
-	"reflect"
 	"strconv"
 	"strings"
 	"time"
 
-	"xorm.io/xorm/convert"
-	"xorm.io/xorm/internal/json"
 	"xorm.io/xorm/internal/utils"
 	"xorm.io/xorm/schemas"
 )
@@ -77,445 +72,3 @@ func (session *Session) str2Time(col *schemas.Column, data string) (outTime time
 func (session *Session) byte2Time(col *schemas.Column, data []byte) (outTime time.Time, outErr error) {
 	return session.str2Time(col, string(data))
 }
-
-// convert a db data([]byte) to a field value
-func (session *Session) bytes2Value(col *schemas.Column, fieldValue *reflect.Value, data []byte) error {
-	if structConvert, ok := fieldValue.Addr().Interface().(convert.Conversion); ok {
-		return structConvert.FromDB(data)
-	}
-
-	if structConvert, ok := fieldValue.Interface().(convert.Conversion); ok {
-		return structConvert.FromDB(data)
-	}
-
-	var v interface{}
-	key := col.Name
-	fieldType := fieldValue.Type()
-
-	switch fieldType.Kind() {
-	case reflect.Complex64, reflect.Complex128:
-		x := reflect.New(fieldType)
-		if len(data) > 0 {
-			err := json.DefaultJSONHandler.Unmarshal(data, x.Interface())
-			if err != nil {
-				return err
-			}
-			fieldValue.Set(x.Elem())
-		}
-	case reflect.Slice, reflect.Array, reflect.Map:
-		v = data
-		t := fieldType.Elem()
-		k := t.Kind()
-		if col.SQLType.IsText() {
-			x := reflect.New(fieldType)
-			if len(data) > 0 {
-				err := json.DefaultJSONHandler.Unmarshal(data, x.Interface())
-				if err != nil {
-					return err
-				}
-				fieldValue.Set(x.Elem())
-			}
-		} else if col.SQLType.IsBlob() {
-			if k == reflect.Uint8 {
-				fieldValue.Set(reflect.ValueOf(v))
-			} else {
-				x := reflect.New(fieldType)
-				if len(data) > 0 {
-					err := json.DefaultJSONHandler.Unmarshal(data, x.Interface())
-					if err != nil {
-						return err
-					}
-					fieldValue.Set(x.Elem())
-				}
-			}
-		} else {
-			return ErrUnSupportedType
-		}
-	case reflect.String:
-		fieldValue.SetString(string(data))
-	case reflect.Bool:
-		v, err := asBool(data)
-		if err != nil {
-			return fmt.Errorf("arg %v as bool: %s", key, err.Error())
-		}
-		fieldValue.Set(reflect.ValueOf(v))
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		sdata := string(data)
-		var x int64
-		var err error
-		// for mysql, when use bit, it returned \x01
-		if col.SQLType.Name == schemas.Bit &&
-			session.engine.dialect.URI().DBType == schemas.MYSQL { // !nashtsai! TODO dialect needs to provide conversion interface API
-			if len(data) == 1 {
-				x = int64(data[0])
-			} else {
-				x = 0
-			}
-		} else if strings.HasPrefix(sdata, "0x") {
-			x, err = strconv.ParseInt(sdata, 16, 64)
-		} else if strings.HasPrefix(sdata, "0") {
-			x, err = strconv.ParseInt(sdata, 8, 64)
-		} else if strings.EqualFold(sdata, "true") {
-			x = 1
-		} else if strings.EqualFold(sdata, "false") {
-			x = 0
-		} else {
-			x, err = strconv.ParseInt(sdata, 10, 64)
-		}
-		if err != nil {
-			return fmt.Errorf("arg %v as int: %s", key, err.Error())
-		}
-		fieldValue.SetInt(x)
-	case reflect.Float32, reflect.Float64:
-		x, err := strconv.ParseFloat(string(data), 64)
-		if err != nil {
-			return fmt.Errorf("arg %v as float64: %s", key, err.Error())
-		}
-		fieldValue.SetFloat(x)
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		x, err := strconv.ParseUint(string(data), 10, 64)
-		if err != nil {
-			return fmt.Errorf("arg %v as int: %s", key, err.Error())
-		}
-		fieldValue.SetUint(x)
-	//Currently only support Time type
-	case reflect.Struct:
-		// !<winxxp>! 增加支持sql.Scanner接口的结构，如sql.NullString
-		if nulVal, ok := fieldValue.Addr().Interface().(sql.Scanner); ok {
-			if err := nulVal.Scan(data); err != nil {
-				return fmt.Errorf("sql.Scan(%v) failed: %s ", data, err.Error())
-			}
-		} else {
-			if fieldType.ConvertibleTo(schemas.TimeType) {
-				x, err := session.byte2Time(col, data)
-				if err != nil {
-					return err
-				}
-				v = x
-				fieldValue.Set(reflect.ValueOf(v).Convert(fieldType))
-			} else if session.statement.UseCascade {
-				table, err := session.engine.tagParser.ParseWithCache(*fieldValue)
-				if err != nil {
-					return err
-				}
-
-				// TODO: current only support 1 primary key
-				if len(table.PrimaryKeys) > 1 {
-					return errors.New("unsupported composited primary key cascade")
-				}
-
-				var pk = make(schemas.PK, len(table.PrimaryKeys))
-				rawValueType := table.ColumnType(table.PKColumns()[0].FieldName)
-				pk[0], err = str2PK(string(data), rawValueType)
-				if err != nil {
-					return err
-				}
-
-				if !pk.IsZero() {
-					// !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())
-					has, err := session.ID(pk).NoCascade().get(structInter.Interface())
-					if err != nil {
-						return err
-					}
-					if has {
-						v = structInter.Elem().Interface()
-						fieldValue.Set(reflect.ValueOf(v))
-					} else {
-						return errors.New("cascade obj is not exist")
-					}
-				}
-			}
-		}
-	case reflect.Ptr:
-		// !nashtsai! TODO merge duplicated codes above
-		//typeStr := fieldType.String()
-		switch fieldType.Elem().Kind() {
-		// case "*string":
-		case schemas.StringType.Kind():
-			x := string(data)
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*bool":
-		case schemas.BoolType.Kind():
-			d := string(data)
-			v, err := strconv.ParseBool(d)
-			if err != nil {
-				return fmt.Errorf("arg %v as bool: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&v).Convert(fieldType))
-		// case "*complex64":
-		case schemas.Complex64Type.Kind():
-			var x complex64
-			if len(data) > 0 {
-				err := json.DefaultJSONHandler.Unmarshal(data, &x)
-				if err != nil {
-					return err
-				}
-				fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-			}
-		// case "*complex128":
-		case schemas.Complex128Type.Kind():
-			var x complex128
-			if len(data) > 0 {
-				err := json.DefaultJSONHandler.Unmarshal(data, &x)
-				if err != nil {
-					return err
-				}
-				fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-			}
-		// case "*float64":
-		case schemas.Float64Type.Kind():
-			x, err := strconv.ParseFloat(string(data), 64)
-			if err != nil {
-				return fmt.Errorf("arg %v as float64: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*float32":
-		case schemas.Float32Type.Kind():
-			var x float32
-			x1, err := strconv.ParseFloat(string(data), 32)
-			if err != nil {
-				return fmt.Errorf("arg %v as float32: %s", key, err.Error())
-			}
-			x = float32(x1)
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*uint64":
-		case schemas.Uint64Type.Kind():
-			var x uint64
-			x, err := strconv.ParseUint(string(data), 10, 64)
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*uint":
-		case schemas.UintType.Kind():
-			var x uint
-			x1, err := strconv.ParseUint(string(data), 10, 64)
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			x = uint(x1)
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*uint32":
-		case schemas.Uint32Type.Kind():
-			var x uint32
-			x1, err := strconv.ParseUint(string(data), 10, 64)
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			x = uint32(x1)
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*uint8":
-		case schemas.Uint8Type.Kind():
-			var x uint8
-			x1, err := strconv.ParseUint(string(data), 10, 64)
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			x = uint8(x1)
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*uint16":
-		case schemas.Uint16Type.Kind():
-			var x uint16
-			x1, err := strconv.ParseUint(string(data), 10, 64)
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			x = uint16(x1)
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*int64":
-		case schemas.Int64Type.Kind():
-			sdata := string(data)
-			var x int64
-			var err error
-			// for mysql, when use bit, it returned \x01
-			if col.SQLType.Name == schemas.Bit &&
-				strings.Contains(session.engine.DriverName(), "mysql") {
-				if len(data) == 1 {
-					x = int64(data[0])
-				} else {
-					x = 0
-				}
-			} else if strings.HasPrefix(sdata, "0x") {
-				x, err = strconv.ParseInt(sdata, 16, 64)
-			} else if strings.HasPrefix(sdata, "0") {
-				x, err = strconv.ParseInt(sdata, 8, 64)
-			} else {
-				x, err = strconv.ParseInt(sdata, 10, 64)
-			}
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*int":
-		case schemas.IntType.Kind():
-			sdata := string(data)
-			var x int
-			var x1 int64
-			var err error
-			// for mysql, when use bit, it returned \x01
-			if col.SQLType.Name == schemas.Bit &&
-				strings.Contains(session.engine.DriverName(), "mysql") {
-				if len(data) == 1 {
-					x = int(data[0])
-				} else {
-					x = 0
-				}
-			} else if strings.HasPrefix(sdata, "0x") {
-				x1, err = strconv.ParseInt(sdata, 16, 64)
-				x = int(x1)
-			} else if strings.HasPrefix(sdata, "0") {
-				x1, err = strconv.ParseInt(sdata, 8, 64)
-				x = int(x1)
-			} else {
-				x1, err = strconv.ParseInt(sdata, 10, 64)
-				x = int(x1)
-			}
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*int32":
-		case schemas.Int32Type.Kind():
-			sdata := string(data)
-			var x int32
-			var x1 int64
-			var err error
-			// for mysql, when use bit, it returned \x01
-			if col.SQLType.Name == schemas.Bit &&
-				session.engine.dialect.URI().DBType == schemas.MYSQL {
-				if len(data) == 1 {
-					x = int32(data[0])
-				} else {
-					x = 0
-				}
-			} else if strings.HasPrefix(sdata, "0x") {
-				x1, err = strconv.ParseInt(sdata, 16, 64)
-				x = int32(x1)
-			} else if strings.HasPrefix(sdata, "0") {
-				x1, err = strconv.ParseInt(sdata, 8, 64)
-				x = int32(x1)
-			} else {
-				x1, err = strconv.ParseInt(sdata, 10, 64)
-				x = int32(x1)
-			}
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*int8":
-		case schemas.Int8Type.Kind():
-			sdata := string(data)
-			var x int8
-			var x1 int64
-			var err error
-			// for mysql, when use bit, it returned \x01
-			if col.SQLType.Name == schemas.Bit &&
-				strings.Contains(session.engine.DriverName(), "mysql") {
-				if len(data) == 1 {
-					x = int8(data[0])
-				} else {
-					x = 0
-				}
-			} else if strings.HasPrefix(sdata, "0x") {
-				x1, err = strconv.ParseInt(sdata, 16, 64)
-				x = int8(x1)
-			} else if strings.HasPrefix(sdata, "0") {
-				x1, err = strconv.ParseInt(sdata, 8, 64)
-				x = int8(x1)
-			} else {
-				x1, err = strconv.ParseInt(sdata, 10, 64)
-				x = int8(x1)
-			}
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*int16":
-		case schemas.Int16Type.Kind():
-			sdata := string(data)
-			var x int16
-			var x1 int64
-			var err error
-			// for mysql, when use bit, it returned \x01
-			if col.SQLType.Name == schemas.Bit &&
-				strings.Contains(session.engine.DriverName(), "mysql") {
-				if len(data) == 1 {
-					x = int16(data[0])
-				} else {
-					x = 0
-				}
-			} else if strings.HasPrefix(sdata, "0x") {
-				x1, err = strconv.ParseInt(sdata, 16, 64)
-				x = int16(x1)
-			} else if strings.HasPrefix(sdata, "0") {
-				x1, err = strconv.ParseInt(sdata, 8, 64)
-				x = int16(x1)
-			} else {
-				x1, err = strconv.ParseInt(sdata, 10, 64)
-				x = int16(x1)
-			}
-			if err != nil {
-				return fmt.Errorf("arg %v as int: %s", key, err.Error())
-			}
-			fieldValue.Set(reflect.ValueOf(&x).Convert(fieldType))
-		// case "*SomeStruct":
-		case reflect.Struct:
-			switch fieldType {
-			// case "*.time.Time":
-			case schemas.PtrTimeType:
-				x, err := session.byte2Time(col, data)
-				if err != nil {
-					return err
-				}
-				v = x
-				fieldValue.Set(reflect.ValueOf(&x))
-			default:
-				if session.statement.UseCascade {
-					structInter := reflect.New(fieldType.Elem())
-					table, err := session.engine.tagParser.ParseWithCache(structInter.Elem())
-					if err != nil {
-						return err
-					}
-
-					if len(table.PrimaryKeys) > 1 {
-						return errors.New("unsupported composited primary key cascade")
-					}
-
-					var pk = make(schemas.PK, len(table.PrimaryKeys))
-					rawValueType := table.ColumnType(table.PKColumns()[0].FieldName)
-					pk[0], err = str2PK(string(data), rawValueType)
-					if err != nil {
-						return err
-					}
-
-					if !pk.IsZero() {
-						// !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
-						has, err := session.ID(pk).NoCascade().get(structInter.Interface())
-						if err != nil {
-							return err
-						}
-						if has {
-							v = structInter.Interface()
-							fieldValue.Set(reflect.ValueOf(v))
-						} else {
-							return errors.New("cascade obj is not exist")
-						}
-					}
-				} else {
-					return fmt.Errorf("unsupported struct type in Scan: %s", fieldValue.Type().String())
-				}
-			}
-		default:
-			return fmt.Errorf("unsupported type in Scan: %s", fieldValue.Type().String())
-		}
-	default:
-		return fmt.Errorf("unsupported type in Scan: %s", fieldValue.Type().String())
-	}
-
-	return nil
-}

session_insert.go

@@ -415,7 +415,12 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 			return 1, nil
 		}
 
-		return 1, convertAssignV(aiValue.Addr(), id, session.engine.DatabaseTZ, session.engine.TZLocation)
+		var refValue = *aiValue
+		if refValue.Kind() != reflect.Ptr {
+			refValue = aiValue.Addr()
+		}
+
+		return 1, convertAssignV(refValue, id, session.engine.DatabaseTZ, session.engine.TZLocation)
 	}
 
 	res, err := session.exec(sqlStr, args...)
@@ -455,7 +460,12 @@ func (session *Session) innerInsert(bean interface{}) (int64, error) {
 		return res.RowsAffected()
 	}
 
-	if err := convertAssignV(aiValue.Addr(), id, session.engine.DatabaseTZ, session.engine.TZLocation); err != nil {
+	var refValue = *aiValue
+	if refValue.Kind() != reflect.Ptr {
+		refValue = aiValue.Addr()
+	}
+
+	if err := convertAssignV(refValue, id, session.engine.DatabaseTZ, session.engine.TZLocation); err != nil {
 		return 0, err
 	}
 

session_raw.go

@@ -6,13 +6,8 @@ package xorm
 
 import (
 	"database/sql"
-	"fmt"
-	"reflect"
-	"strconv"
-	"time"
 
 	"xorm.io/xorm/core"
-	"xorm.io/xorm/schemas"
 )
 
 func (session *Session) queryPreprocess(sqlStr *string, paramStr ...interface{}) {
@@ -75,61 +70,6 @@ func (session *Session) queryRow(sqlStr string, args ...interface{}) *core.Row {
 	return core.NewRow(session.queryRows(sqlStr, args...))
 }
 
-func value2String(rawValue *reflect.Value) (str string, err error) {
-	aa := reflect.TypeOf((*rawValue).Interface())
-	vv := reflect.ValueOf((*rawValue).Interface())
-	switch aa.Kind() {
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		str = strconv.FormatInt(vv.Int(), 10)
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
-		str = strconv.FormatUint(vv.Uint(), 10)
-	case reflect.Float32, reflect.Float64:
-		str = strconv.FormatFloat(vv.Float(), 'f', -1, 64)
-	case reflect.String:
-		str = vv.String()
-	case reflect.Array, reflect.Slice:
-		switch aa.Elem().Kind() {
-		case reflect.Uint8:
-			data := rawValue.Interface().([]byte)
-			str = string(data)
-			if str == "\x00" {
-				str = "0"
-			}
-		default:
-			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
-		}
-	// time type
-	case reflect.Struct:
-		if aa.ConvertibleTo(schemas.TimeType) {
-			str = vv.Convert(schemas.TimeType).Interface().(time.Time).Format(time.RFC3339Nano)
-		} else {
-			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
-		}
-	case reflect.Bool:
-		str = strconv.FormatBool(vv.Bool())
-	case reflect.Complex128, reflect.Complex64:
-		str = fmt.Sprintf("%v", vv.Complex())
-	/* TODO: unsupported types below
-	   case reflect.Map:
-	   case reflect.Ptr:
-	   case reflect.Uintptr:
-	   case reflect.UnsafePointer:
-	   case reflect.Chan, reflect.Func, reflect.Interface:
-	*/
-	default:
-		err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
-	}
-	return
-}
-
-func value2Bytes(rawValue *reflect.Value) ([]byte, error) {
-	str, err := value2String(rawValue)
-	if err != nil {
-		return nil, err
-	}
-	return []byte(str), nil
-}
-
 func (session *Session) queryBytes(sqlStr string, args ...interface{}) ([]map[string][]byte, error) {
 	rows, err := session.queryRows(sqlStr, args...)
 	if err != nil {