Refactor get

convert.go

@@ -579,10 +579,7 @@ func convertAssign(dest, src interface{}, originalLocation *time.Location, conve
 }
 
 func convertAssignV(dpv reflect.Value, src interface{}, originalLocation, convertedLocation *time.Location) error {
-	if dpv.Kind() != reflect.Ptr {
+	if dpv.Kind() == reflect.Ptr && dpv.IsNil() {
-		return errors.New("destination not a pointer")
-	}
-	if dpv.IsNil() {
 		return errNilPtr
 	}
 
@@ -640,6 +637,36 @@ 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.Array:
+		var bs []byte
+		switch t := src.(type) {
+		case string:
+			bs = []byte(t)
+		case []byte:
+			bs = t
+		}
+
+		if bs != nil {
+			if dv.Len() > 0 {
+				for i := 0; i < dv.Len(); i++ {
+					if i < len(bs) {
+						dv.Index(i).Set(reflect.ValueOf(bs[i]))
+					}
+				}
+			} else {
+				for i := 0; i < len(bs); i++ {
+					dv.Set(reflect.Append(dv, reflect.ValueOf(bs[i])))
+				}
+			}
+			return nil
+		}
 	}
 
 	return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dpv.Interface())
@@ -682,16 +709,39 @@ 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) {
-		return false, nil
+	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 v[0] == 0x00 {
+			return false, nil
+		} else if v[0] == 0x01 {
+			return true, nil
+		}
+		return strconv.ParseBool(string(v))
+	case string:
+		return strconv.ParseBool(v)
+	default:
+		return false, fmt.Errorf("unknow type %T as bool", src)
 	}
-	if bs[0] == 0x00 {
-		return false, nil
-	} else if bs[0] == 0x01 {
-		return true, nil
-	}
-	return strconv.ParseBool(string(bs))
 }
 
 // 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,21 @@ 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) {
-		m.Year, _ = strconv.Atoi(seps[0])
+	case []byte:
-		m.Month, _ = strconv.Atoi(seps[1])
+		s = string(t)
-		m.Day, _ = strconv.Atoi(seps[2])
+	case string:
-		return nil
+		s = t
+	default:
+		return fmt.Errorf("scan data not fit %T", value)
 	}
 
-	return errors.New("scan data not fit []byte")
+	seps := strings.Split(string(s), "/")
+	m.Year, _ = strconv.Atoi(seps[0])
+	m.Month, _ = strconv.Atoi(seps[1])
+	m.Day, _ = strconv.Atoi(seps[2])
+	return nil
 }
 
 func (m CustomStruct) Value() (driver.Value, error) {

session.go

@@ -365,25 +365,25 @@ func (session *Session) doPrepare(db *core.DB, sqlStr string) (stmt *core.Stmt,
 	return
 }
 
-func (session *Session) getField(dataStruct *reflect.Value, key string, table *schemas.Table, idx int) (*reflect.Value, error) {
+func (session *Session) getField(dataStruct *reflect.Value, key string, table *schemas.Table, idx int) (*schemas.Column, *reflect.Value, error) {
 	var col *schemas.Column
 	if col = table.GetColumnIdx(key, idx); col == nil {
-		return nil, ErrFieldIsNotExist{key, table.Name}
+		return nil, nil, ErrFieldIsNotExist{key, table.Name}
 	}
 
 	fieldValue, err := col.ValueOfV(dataStruct)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	if fieldValue == nil {
-		return nil, ErrFieldIsNotValid{key, table.Name}
+		return nil, nil, ErrFieldIsNotValid{key, table.Name}
 	}
 
 	if !fieldValue.IsValid() || !fieldValue.CanSet() {
-		return nil, ErrFieldIsNotValid{key, table.Name}
+		return nil, nil, ErrFieldIsNotValid{key, table.Name}
 	}
 
-	return fieldValue, nil
+	return col, fieldValue, nil
 }
 
 // Cell cell is a result of one column field
@@ -436,6 +436,38 @@ func (session *Session) row2Slice(rows *core.Rows, fields []string, bean interfa
 	return scanResults, nil
 }
 
+func (session *Session) setJSON(fieldValue *reflect.Value, fieldType reflect.Type, vv reflect.Value, rawValueType reflect.Type) error {
+	var bs []byte
+	if rawValueType.Kind() == reflect.String {
+		bs = []byte(vv.String())
+	} else if rawValueType.ConvertibleTo(schemas.BytesType) {
+		bs = vv.Bytes()
+	} else {
+		return fmt.Errorf("unsupported database data type: %v", rawValueType.Kind())
+	}
+
+	if len(bs) > 0 {
+		if fieldType.Kind() == reflect.String {
+			fieldValue.SetString(string(bs))
+			return nil
+		}
+		if fieldValue.CanAddr() {
+			err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface())
+			if err != nil {
+				return err
+			}
+		} else {
+			x := reflect.New(fieldType)
+			err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface())
+			if err != nil {
+				return err
+			}
+			fieldValue.Set(x.Elem())
+		}
+	}
+	return nil
+}
+
 func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflect.Value,
 	scanResult interface{}, table *schemas.Table) error {
 	v, ok := scanResult.(*interface{})
@@ -482,35 +514,7 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 	fieldType := fieldValue.Type()
 
 	if col.IsJSON {
-		var bs []byte
+		return session.setJSON(fieldValue, fieldType, vv, rawValueType)
-		if rawValueType.Kind() == reflect.String {
-			bs = []byte(vv.String())
-		} else if rawValueType.ConvertibleTo(schemas.BytesType) {
-			bs = vv.Bytes()
-		} else {
-			return fmt.Errorf("unsupported database data type: %s %v", col.Name, rawValueType.Kind())
-		}
-
-		if len(bs) > 0 {
-			if fieldType.Kind() == reflect.String {
-				fieldValue.SetString(string(bs))
-				return nil
-			}
-			if fieldValue.CanAddr() {
-				err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface())
-				if err != nil {
-					return err
-				}
-			} else {
-				x := reflect.New(fieldType)
-				err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface())
-				if err != nil {
-					return err
-				}
-				fieldValue.Set(x.Elem())
-			}
-		}
-		return nil
 	}
 
 	switch fieldType.Kind() {
@@ -529,32 +533,26 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 		}
 		return nil
 	case reflect.Complex64, reflect.Complex128:
-		// TODO: reimplement this
+		return session.setJSON(fieldValue, fieldType, vv, rawValueType)
-		var bs []byte
+	case reflect.Map:
-		if rawValueType.Kind() == reflect.String {
+		switch rawValueType.Kind() {
-			bs = []byte(vv.String())
+		case reflect.String:
-		} else if rawValueType.ConvertibleTo(schemas.BytesType) {
+			return session.setJSON(fieldValue, fieldType, vv, rawValueType)
-			bs = vv.Bytes()
+		case reflect.Slice:
+			return session.setJSON(fieldValue, fieldType, vv, rawValueType)
+		default:
+			return fmt.Errorf("unsupported %v -> %T", scanResult, fieldType)
 		}
-
-		if len(bs) > 0 {
-			if fieldValue.CanAddr() {
-				err := json.DefaultJSONHandler.Unmarshal(bs, fieldValue.Addr().Interface())
-				if err != nil {
-					return err
-				}
-			} else {
-				x := reflect.New(fieldType)
-				err := json.DefaultJSONHandler.Unmarshal(bs, x.Interface())
-				if err != nil {
-					return err
-				}
-				fieldValue.Set(x.Elem())
-			}
-		}
-		return nil
 	case reflect.Slice, reflect.Array:
 		switch rawValueType.Kind() {
+		case reflect.String:
+			x := reflect.New(fieldType)
+			err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), x.Interface())
+			if err != nil {
+				return err
+			}
+			fieldValue.Set(x.Elem())
+			return nil
 		case reflect.Slice, reflect.Array:
 			switch rawValueType.Elem().Kind() {
 			case reflect.Uint8:
@@ -583,37 +581,6 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 				}
 			}
 		}
-	case reflect.String:
-		if rawValueType.Kind() == reflect.String {
-			fieldValue.SetString(vv.String())
-			return nil
-		}
-	case reflect.Bool:
-		if rawValueType.Kind() == reflect.Bool {
-			fieldValue.SetBool(vv.Bool())
-			return nil
-		}
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		switch rawValueType.Kind() {
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			fieldValue.SetInt(vv.Int())
-			return nil
-		}
-	case reflect.Float32, reflect.Float64:
-		switch rawValueType.Kind() {
-		case reflect.Float32, reflect.Float64:
-			fieldValue.SetFloat(vv.Float())
-			return nil
-		}
-	case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-		switch rawValueType.Kind() {
-		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
-			fieldValue.SetUint(vv.Uint())
-			return nil
-		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-			fieldValue.SetUint(uint64(vv.Int()))
-			return nil
-		}
 	case reflect.Struct:
 		if fieldType.ConvertibleTo(schemas.BigFloatType) {
 			v, err := asBigFloat(scanResult)
@@ -677,28 +644,6 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 				return nil
 			}
 			session.engine.logger.Errorf("sql.Sanner error: %v", err)
-		} else if col.IsJSON {
-			if rawValueType.Kind() == reflect.String {
-				x := reflect.New(fieldType)
-				if len([]byte(vv.String())) > 0 {
-					err := json.DefaultJSONHandler.Unmarshal([]byte(vv.String()), x.Interface())
-					if err != nil {
-						return err
-					}
-					fieldValue.Set(x.Elem())
-				}
-				return nil
-			} else if rawValueType.Kind() == reflect.Slice {
-				x := reflect.New(fieldType)
-				if len(vv.Bytes()) > 0 {
-					err := json.DefaultJSONHandler.Unmarshal(vv.Bytes(), x.Interface())
-					if err != nil {
-						return err
-					}
-					fieldValue.Set(x.Elem())
-				}
-				return nil
-			}
 		} else if session.statement.UseCascade {
 			table, err := session.engine.tagParser.ParseWithCache(*fieldValue)
 			if err != nil {
@@ -731,42 +676,30 @@ func (session *Session) convertBeanField(col *schemas.Column, fieldValue *reflec
 			}
 			return nil
 		}
+		return session.setJSON(fieldValue, fieldType, vv, rawValueType)
 	} // 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) {
-	defer func() {
+	defer executeAfterSet(bean, fields, scanResults)
-		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
+		idx, ok := tempMap[lKey]
-
+		if !ok {
-		if idx, ok = tempMap[lKey]; !ok {
 			idx = 0
 		} else {
 			idx = idx + 1
 		}
-
 		tempMap[lKey] = idx
-		col := table.GetColumnIdx(key, idx)
 
-		var scanResult = scanResults[ii]
+		col, fieldValue, err := session.getField(dataStruct, key, table, idx)
-
-		fieldValue, err := session.getField(dataStruct, key, table, idx)
 		if err != nil {
 			if _, ok := err.(ErrFieldIsNotValid); !ok {
 				session.engine.logger.Warnf("%v", err)
@@ -777,6 +710,7 @@ func (session *Session) slice2Bean(scanResults []interface{}, fields []string, b
 			continue
 		}
 
+		var scanResult = scanResults[ii]
 		if err := session.convertBeanField(col, fieldValue, scanResult, table); err != nil {
 			return nil, err
 		}

session_get.go

@@ -70,10 +70,6 @@ func (session *Session) get(bean interface{}) (bool, error) {
 		}
 	}
 
-	var sqlStr string
-	var args []interface{}
-	var err error
-
 	if session.statement.RawSQL == "" {
 		if len(session.statement.TableName()) <= 0 {
 			return false, ErrTableNotFound