增加slice参数类型支持，更好的支持多条记录插入

Author: xfali

parsing/xml/dynamics.go

@@ -13,7 +13,6 @@ import (
 	"fmt"
 	"github.com/xfali/gobatis/logging"
 	"github.com/xfali/gobatis/parsing"
-	"github.com/xfali/gobatis/reflection"
 	"strconv"
 	"strings"
 	"unicode"
@@ -138,6 +137,20 @@ func Compare(src string, getFunc func(key string) string) bool {
 	return false
 }
 
+func getKey(src string) string {
+	if src == "" {
+		return ""
+	}
+	if src[:1] == "{" {
+		index := strings.Index(src, "}")
+		if index == -1 {
+			return src
+		}
+		return src[1:index]
+	}
+	return src
+}
+
 func getValueFromFunc(src string, getFunc func(key string) string) string {
 	if src == "" {
 		return ""
@@ -256,26 +269,30 @@ func (de *Foreach) Format(getFunc func(key string) string) string {
 		return ""
 	}
 
-	listStr := getValueFromFunc(de.Collection, getFunc)
-	if listStr == "" || listStr == "nil" {
-		return ""
-	}
-
-	elems := reflection.ParseSliceParamString(listStr)
+	collectionKey := getKey(de.Collection)
+	value := getValueFromFunc(de.Collection, getFunc)
+	//if value == "" || value == "nil" {
+	//	return ""
+	//}
+	//
+	//elems := reflection.ParseSliceParamString(value)
+	//length := len(elems)
+	length, _ := strconv.Atoi(value)
 	ret := strings.Builder{}
 	ret.WriteString(de.Open)
-	itemStr := fmt.Sprintf("#{%s}", de.Item)
 	indexStr := fmt.Sprintf("#{%s}", de.Index)
-	length := len(elems)
+
 	originData := strings.TrimSpace(de.Data)
 	realStr := ""
-	for i, v := range elems {
-		realStr = strings.Replace(originData, itemStr, v, -1)
+	i := 0
+	for i < length {
+		realStr = strings.Replace(originData, de.Item, fmt.Sprintf("%s[%d]", collectionKey, i), -1)
 		realStr = strings.Replace(realStr, indexStr, strconv.Itoa(i), -1)
 		ret.WriteString(realStr)
 		if i < length-1 {
 			ret.WriteString(de.Separator)
 		}
+		i++
 	}
 	ret.WriteString(de.Close)
 

reflection/parseparam.go

@@ -9,6 +9,7 @@
 package reflection
 
 import (
+	"fmt"
 	"reflect"
 	"strconv"
 	"strings"
@@ -34,11 +35,11 @@ func ParseParams(params ...interface{}) map[string]interface{} {
 
 func (parser *paramParser) innerParse(params ...interface{}) {
 	for i := range params {
-		parser.parseOne(params[i])
+		parser.parseOne("", params[i])
 	}
 }
 
-func (parser *paramParser) parseOne(v interface{}) {
+func (parser *paramParser) parseOne(parentKey string, v interface{}) {
 	rt := reflect.TypeOf(v)
 	rv := reflect.ValueOf(v)
 
@@ -48,47 +49,53 @@ func (parser *paramParser) parseOne(v interface{}) {
 	}
 
 	if IsSimpleType(rt) {
-		parser.ret[strconv.Itoa(parser.index)] = v
-		parser.index++
+		if parentKey == "" {
+			parser.ret[parentKey+strconv.Itoa(parser.index)] = v
+			parser.index++
+		} else {
+			parser.ret[parentKey[:len(parentKey)-1]] = v
+		}
 	} else if rt.Kind() == reflect.Struct {
 		oi, _ := GetStructInfo(v)
 		structMap := oi.MapValue()
 		for key, value := range structMap {
-			parser.ret[structKey(oi, key)] = value
+			parser.ret[parentKey+structKey(oi, key)] = value
 		}
 	} else if rt.Kind() == reflect.Slice {
-		//l := rv.Len()
-		//for i := 0; i < l; i++ {
-		//    elemV := rv.Index(i)
-		//    if !elemV.CanInterface() {
-		//        elemV = reflect.Indirect(elemV)
-		//    }
-		//    parser.parseOne(elemV.Interface())
-		//}
 		l := rv.Len()
-		builder := strings.Builder{}
 		for i := 0; i < l; i++ {
 			elemV := rv.Index(i)
 			if !elemV.CanInterface() {
 				elemV = reflect.Indirect(elemV)
 			}
-			if elemV.Kind() == reflect.String {
-				builder.WriteString(elemV.String())
-			} else {
-				var str string
-				if SafeSetValue(reflect.ValueOf(&str), elemV.Interface()) {
-					builder.WriteString(str)
-				} else {
-					//log
-				}
-			}
-
-			if i < l-1 {
-				builder.WriteString(slice_param_separator)
-			}
+			parser.parseOne(fmt.Sprintf("%s%d[%d].", parentKey, parser.index, i), elemV.Interface())
 		}
-		parser.ret[strconv.Itoa(parser.index)] = builder.String()
+		parser.ret[strconv.Itoa(parser.index)] = l
 		parser.index++
+		//l := rv.Len()
+		//builder := strings.Builder{}
+		//for i := 0; i < l; i++ {
+		//	elemV := rv.Index(i)
+		//	if !elemV.CanInterface() {
+		//		elemV = reflect.Indirect(elemV)
+		//	}
+		//	if elemV.Kind() == reflect.String {
+		//		builder.WriteString(elemV.String())
+		//	} else {
+		//		var str string
+		//		if SafeSetValue(reflect.ValueOf(&str), elemV.Interface()) {
+		//			builder.WriteString(str)
+		//		} else {
+		//			//log
+		//		}
+		//	}
+		//
+		//	if i < l-1 {
+		//		builder.WriteString(slice_param_separator)
+		//	}
+		//}
+		//parser.ret[strconv.Itoa(parser.index)] = builder.String()
+		//parser.index++
 	} else if rt.Kind() == reflect.Map {
 		keys := rv.MapKeys()
 		for _, key := range keys {
@@ -99,7 +106,7 @@ func (parser *paramParser) parseOne(v interface{}) {
 					if !value.CanInterface() {
 						value = reflect.Indirect(value)
 					}
-					parser.ret[key.String()] = value
+					parser.ret[parentKey+key.String()] = value
 				}
 			}
 		}
@@ -110,6 +117,25 @@ func ParseSliceParamString(src string) []string {
 	return strings.Split(src, slice_param_separator)
 }
 
+func (parser *paramParser) setSliceValue(parentKey string) string {
+	key := fmt.Sprintf("%s%d[", parentKey, parser.index)
+	builder := strings.Builder{}
+	parser.ret[strconv.Itoa(parser.index)] = builder.String()
+	for k := range parser.ret {
+		if strings.Index(k, key) == 0 {
+			builder.WriteString(k)
+			builder.WriteString(slice_param_separator)
+		}
+	}
+
+	s := builder.String()
+	if len(s) > 7 {
+		return s[:len(s)-7]
+	} else {
+		return s
+	}
+}
+
 func structKey(oi *StructInfo, field string) string {
 	return oi.Name + "." + field
 }

test/cmd/template/test_table_mapper.tmpl

@@ -1,3 +1,6 @@
+{{/*This file was generated by xfali/gobatis-cmd at*/}}
+{{/*2020-02-07 11:43:44.4379882 +0800 CST m=+0.092005301*/}}
+
 {{define "selectTestTable"}}
 SELECT "id","username","password","createtime" FROM "test_table"
 {{where (ne .Id 0) "AND" "id" .Id "" | where (ne .Username "") "AND" "username" .Username | where (ne .Password "") "AND" "password" .Password | where (ne .Createtime ) "AND" "createtime" .Createtime}}
@@ -7,7 +10,6 @@ SELECT "id","username","password","createtime" FROM "test_table"
 INSERT INTO "test_table"("id","username","password","createtime")
 VALUES(
 {{.Id}}, '{{.Username}}', '{{.Password}}', {{.Createtime}})
-RETURNING ID
 {{end}}
 
 {{define "updateTestTable"}}

test/cmd/test_table.go

@@ -1,3 +1,6 @@
+//This file was generated by xfali/gobatis-cmd at
+//2020-02-07 11:43:44.4189871 +0800 CST m=+0.073004201
+
 package test_package
 
 import "time"

test/cmd/test_table_proxy.go

@@ -1,3 +1,6 @@
+//This file was generated by xfali/gobatis-cmd at
+//2020-02-07 11:43:44.4459887 +0800 CST m=+0.100005801
+
 package test_package
 
 import (
@@ -7,7 +10,7 @@ import (
 func init() {
     modelV := TestTable{}
     gobatis.RegisterModel(&modelV)
-    //gobatis.RegisterMapperFile("./xml/test_table_mapper.xml")
+    gobatis.RegisterTemplateFile("./template/test_table_mapper.tmpl")
 }
 
 func SelectTestTable(sess *gobatis.Session, model TestTable) ([]TestTable, error) {

test/cmd/xml/test_table_mapper.xml

@@ -1,3 +1,6 @@
+<!--This file was generated by xfali/gobatis-cmd at -->
+<!--2020-02-07 11:45:05.5246261 +0800 CST m=+0.099005701-->
+
 <mapper namespace="test_package.TestTable">
     <sql id="columns_id">"id","username","password","createtime"</sql>
 
@@ -29,7 +32,6 @@
         #{TestTable.password},
         #{TestTable.createtime}
         )
-        RETURNING ID
     </insert>
 
     <update id="updateTestTable">

test/reflection_test.go

@@ -169,10 +169,33 @@ func TestReflectionParseSlice(t *testing.T) {
 	}
 	for k, v := range ret {
 		t.Logf("complex key : %s value : %v", k, v)
-		elems := reflection.ParseSliceParamString(v.(string))
-		for _, e := range elems {
-			t.Logf("slice elem %v\n", e)
-		}
+		//elems := reflection.ParseSliceParamString(v.(string))
+		//for _, e := range elems {
+		//	t.Logf("slice elem %v\n", e)
+		//}
+	}
+}
+
+func TestReflectionParseStructSlice(t *testing.T) {
+	ret := reflection.ParseParams([]testParseStruct{
+		{
+			Username: "user1",
+			Password: "pw1",
+		},
+		{
+			Username: "user2",
+			Password: "pw2",
+		},
+	})
+	if len(ret) == 0 {
+		t.Fail()
+	}
+	for k, v := range ret {
+		t.Logf("complex key : %s value : %v", k, v)
+		//elems := reflection.ParseSliceParamString(v.(string))
+		//for _, e := range elems {
+		//	t.Logf("slice elem %v\n", e)
+		//}
 	}
 }
 

test/xmlparse_test.go

@@ -386,7 +386,69 @@ func TestXmlDynamicForeach(t *testing.T) {
 		params := []string{
 			"first", "second",
 		}
-		ret := m.Replace(params)
+		ret, err := m.ParseMetadata("mysql", params)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("arg first : %s\n", ret)
+
+	})
+}
+
+func TestXmlDynamicForeach2(t *testing.T) {
+	src := `INSERT INTO TEST_TABLE(id, username, password) VALUES(
+        <foreach item="item" index="index" collection="{0}"
+            open="(" separator="," close=")">
+            #{item}
+        </foreach>
+		)
+`
+	logging.SetLevel(logging.DEBUG)
+	m, err := xml.ParseDynamic(src, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Run("foreach first", func(t *testing.T) {
+		params := []string{
+			"first", "second",
+		}
+		ret, err := m.ParseMetadata("mysql", params)
+		if err != nil {
+			t.Fatal(err)
+		}
+		t.Logf("arg first : %s\n", ret)
+
+	})
+}
+
+func TestXmlDynamicForeach3(t *testing.T) {
+	src := `INSERT INTO TEST_TABLE(id, username, password) VALUES(
+        <foreach item="item" index="index" collection="{0}"
+            open="" separator="," close="">
+            (#{item.testParseStruct.Username}, #{item.testParseStruct.Password})
+        </foreach>
+		)
+`
+	logging.SetLevel(logging.DEBUG)
+	m, err := xml.ParseDynamic(src, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	t.Run("foreach first", func(t *testing.T) {
+		params := []testParseStruct{
+			{
+				Username: "user1",
+				Password: "pw1",
+			},
+			{
+				Username: "user2",
+				Password: "pw2",
+			},
+		}
+		ret, err := m.ParseMetadata("mysql", params)
+		if err != nil {
+			t.Fatal(err)
+		}
 		t.Logf("arg first : %s\n", ret)
 
 	})