Merge remote-tracking branch 'upstream/dev' into dev

base_test.go

@@ -359,7 +359,7 @@ func updateSameMapper(engine *Engine, t *testing.T) {
 	}
 }
 
-func testdelete(engine *Engine, t *testing.T) {
+func testDelete(engine *Engine, t *testing.T) {
 	user := Userinfo{Uid: 1}
 	cnt, err := engine.Delete(&user)
 	if err != nil {
@@ -3788,8 +3788,8 @@ func testAll(engine *Engine, t *testing.T) {
 	insertTwoTable(engine, t)
 	fmt.Println("-------------- update --------------")
 	update(engine, t)
-	fmt.Println("-------------- testdelete --------------")
-	testdelete(engine, t)
+	fmt.Println("-------------- testDelete --------------")
+	testDelete(engine, t)
 	fmt.Println("-------------- get --------------")
 	get(engine, t)
 	fmt.Println("-------------- cascadeGet --------------")

helpers.go

@@ -1,8 +1,12 @@
 package xorm
 
 import (
+	"database/sql"
+	"fmt"
 	"reflect"
+	"strconv"
 	"strings"
+	"time"
 )
 
 func indexNoCase(s, sep string) int {
@@ -61,3 +65,72 @@ func sliceEq(left, right []string) bool {
 
 	return true
 }
+
+func value2Bytes(rawValue *reflect.Value) (data []byte, err error) {
+
+	aa := reflect.TypeOf((*rawValue).Interface())
+	vv := reflect.ValueOf((*rawValue).Interface())
+
+	var str string
+	switch aa.Kind() {
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		str = strconv.FormatInt(vv.Int(), 10)
+		data = []byte(str)
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		str = strconv.FormatUint(vv.Uint(), 10)
+		data = []byte(str)
+	case reflect.Float32, reflect.Float64:
+		str = strconv.FormatFloat(vv.Float(), 'f', -1, 64)
+		data = []byte(str)
+	case reflect.String:
+		str = vv.String()
+		data = []byte(str)
+	case reflect.Array, reflect.Slice:
+		switch aa.Elem().Kind() {
+		case reflect.Uint8:
+			data = rawValue.Interface().([]byte)
+		default:
+			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
+		}
+	//时间类型
+	case reflect.Struct:
+		if aa == reflect.TypeOf(c_TIME_DEFAULT) {
+			str = rawValue.Interface().(time.Time).Format(time.RFC3339Nano)
+			data = []byte(str)
+		} else {
+			err = fmt.Errorf("Unsupported struct type %v", vv.Type().Name())
+		}
+	case reflect.Bool:
+		str = strconv.FormatBool(vv.Bool())
+		data = []byte(str)
+	case reflect.Complex128, reflect.Complex64:
+		str = fmt.Sprintf("%v", vv.Complex())
+		data = []byte(str)
+	/* 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 rows2maps(rows *sql.Rows) (resultsSlice []map[string][]byte, err error) {
+	fields, err := rows.Columns()
+	if err != nil {
+		return nil, err
+	}
+	for rows.Next() {
+		result, err := row2map(rows, fields)
+		if err != nil {
+			return nil, err
+		}
+		resultsSlice = append(resultsSlice, result)
+	}
+
+	return resultsSlice, nil
+}

rows.go

@@ -9,12 +9,13 @@ import (
 type Rows struct {
 	NoTypeCheck bool
 
-	session   *Session
-	stmt      *sql.Stmt
-	rows      *sql.Rows
-	fields    []string
-	beanType  reflect.Type
-	lastError error
+	session     *Session
+	stmt        *sql.Stmt
+	rows        *sql.Rows
+	fields      []string
+	fieldsCount int
+	beanType    reflect.Type
+	lastError   error
 }
 
 func newRows(session *Session, bean interface{}) (*Rows, error) {
@@ -66,6 +67,7 @@ func newRows(session *Session, bean interface{}) (*Rows, error) {
 		defer rows.Close()
 		return nil, err
 	}
+	rows.fieldsCount = len(rows.fields)
 
 	return rows, nil
 }
@@ -97,11 +99,13 @@ func (rows *Rows) Scan(bean interface{}) error {
 		return fmt.Errorf("scan arg is incompatible type to [%v]", rows.beanType)
 	}
 
-	result, err := row2map(rows.rows, rows.fields) // !nashtsai! TODO remove row2map then scanMapIntoStruct conversation for better performance
-	if err == nil {
-		err = rows.session.scanMapIntoStruct(bean, result)
-	}
-	return err
+	return rows.session.row2Bean(rows.rows, rows.fields, rows.fieldsCount, bean)
+
+	// result, err := row2map(rows.rows, rows.fields) // !nashtsai! TODO remove row2map then scanMapIntoStruct conversation for better performance
+	// if err == nil {
+	// 	err = rows.session.scanMapIntoStruct(bean, result)
+	// }
+	// return err
 }
 
 // // Columns returns the column names. Columns returns an error if the rows are closed, or if the rows are from QueryRow and there was a deferred error.

table.go

@@ -163,6 +163,7 @@ func Type2SQLType(t reflect.Type) (st SQLType) {
 		if t == reflect.TypeOf(c_TIME_DEFAULT) {
 			st = SQLType{DateTime, 0, 0}
 		} else {
+			// TODO need to handle association struct
 			st = SQLType{Text, 0, 0}
 		}
 	case reflect.Ptr: