增加foreach动态sql支持

Author: xfali

README.md

@@ -17,10 +17,11 @@ where| where 元素只会在至少有一个子元素的条件返回 SQL 子句
 set | set 元素会动态前置 SET 关键字，同时也会删掉无关的逗号。
 include | 使用sql标签定义的语句替换。
 choose<br>when<br>otherwise | 有时我们不想应用到所有的条件语句，而只想从中择其一项。针对这种情况，gobatis 提供了 choose 元素，它有点像switch 语句。
+foreach | foreach 允许指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。
 
 ## 待完成项
 
-* 继续完善动态sql支持（foreach、trim）
+* 继续完善动态sql支持（trim）
 * ~~性能优化：增加动态sql缓存~~
 (已经实现，但测试发现性能提升很小，目前该功能被关闭)
 

parsing/dynamics.go

@@ -41,6 +41,10 @@ func (m *DynamicData) ReplaceWithMap(objParams map[string]interface{}) string {
 
     getFunc := func(s string) string {
         if o, ok := objParams[s]; ok {
+            if str, ok := o.(string); ok {
+                return str
+            }
+
             //zero time convert to empty string (for <if> </if> element)
             if ti, ok := o.(time.Time); ok {
                 if ti.IsZero() {
@@ -49,6 +53,7 @@ func (m *DynamicData) ReplaceWithMap(objParams map[string]interface{}) string {
                     return ti.String()
                 }
             }
+
             var str string
             reflection.SafeSetValue(reflect.ValueOf(&str), o)
             return str

parsing/xml/dynamics.go

@@ -10,8 +10,11 @@ package xml
 
 import (
     "encoding/xml"
+    "fmt"
     "github.com/xfali/gobatis/logging"
     "github.com/xfali/gobatis/parsing"
+    "github.com/xfali/gobatis/reflection"
+    "strconv"
     "strings"
     "unicode"
 )
@@ -23,6 +26,7 @@ type Foreach struct {
     Index      string `xml:"index,attr"`
     Open       string `xml:"open,attr"`
     Close      string `xml:"close,attr"`
+    Data       string `xml:",chardata"`
 }
 
 type Sql struct {
@@ -43,7 +47,7 @@ type Include struct {
 
 type If struct {
     Test string `xml:"test,attr"`
-    Date string `xml:",chardata"`
+    Data string `xml:",chardata"`
 }
 
 type Where struct {
@@ -60,7 +64,7 @@ type When struct {
 }
 
 type Otherwise struct {
-    Date string `xml:",chardata"`
+    Data string `xml:",chardata"`
 }
 
 type Choose struct {
@@ -91,15 +95,15 @@ func (de *If) Format(getFunc func(key string) string) string {
                 return ""
             }
         }
-        return strings.TrimSpace(de.Date)
+        return strings.TrimSpace(de.Data)
     }
 
     ret := false
     if len(orStrs) != 0 {
         for _, v := range orStrs {
             ret = Compare(v, getFunc)
             if ret == true {
-                return strings.TrimSpace(de.Date)
+                return strings.TrimSpace(de.Data)
             }
         }
         if ret == false {
@@ -242,11 +246,42 @@ func (de *Choose) Format(getFunc func(key string) string) string {
     }
     retStr := ret.String()
     if retStr == "" {
-        retStr = strings.TrimSpace(de.Otherwise.Date)
+        retStr = strings.TrimSpace(de.Otherwise.Data)
     }
     return retStr
 }
 
+func (de *Foreach) Format(getFunc func(key string) string) string {
+    if de.Collection == "" {
+        return ""
+    }
+
+    listStr := getValueFromFunc(de.Collection, getFunc)
+    if listStr == "" || listStr == "nil" {
+        return ""
+    }
+
+    elems := reflection.ParseSliceParamString(listStr)
+    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)
+        realStr = strings.Replace(realStr, indexStr, strconv.Itoa(i), -1)
+        ret.WriteString(realStr)
+        if i < length-1 {
+            ret.WriteString(de.Separator)
+        }
+    }
+    ret.WriteString(de.Close)
+
+    return ret.String()
+}
+
 func escape(src string) string {
     src = strings.Replace(src, "&lt;", "<", -1)
     src = strings.Replace(src, "&gt;", ">", -1)
@@ -266,13 +301,15 @@ type WhereProcessor string
 type SetProcessor string
 type IncludeProcessor string
 type ChooseProcessor string
+type ForeachProcessor string
 
 var gProcessorMap = map[string]typeProcessor{
     "if":      IfProcessor("if"),
     "where":   WhereProcessor("where"),
     "set":     SetProcessor("set"),
     "include": IncludeProcessor("include"),
     "choose":  ChooseProcessor("choose"),
+    "foreach": ForeachProcessor("foreach"),
 }
 
 func (d IfProcessor) EndStr() string {
@@ -335,6 +372,18 @@ func (d ChooseProcessor) Parse(src string) parsing.DynamicElement {
     return &v
 }
 
+func (d ForeachProcessor) EndStr() string {
+    return "</" + string(d) + ">"
+}
+
+func (d ForeachProcessor) Parse(src string) parsing.DynamicElement {
+    v := Foreach{}
+    if xml.Unmarshal([]byte(src), &v) != nil {
+        logging.Warn("parse if element failed")
+    }
+    return &v
+}
+
 func ParseDynamic(src string, sqls []Sql) (*parsing.DynamicData, error) {
     src = escape(src)
 

reflection/parseparam.go

@@ -9,8 +9,14 @@
 package reflection
 
 import (
+    "github.com/xormplus/builder"
     "reflect"
     "strconv"
+    "strings"
+)
+
+const(
+    slice_param_separator = "_&eLEm_"
 )
 
 type paramParser struct {
@@ -60,7 +66,29 @@ func (parser *paramParser)parseOne(v interface{}) {
         //    }
         //    parser.parseOne(elemV.Interface())
         //}
-        parser.ret[strconv.Itoa(parser.index)] = v
+        l := rv.Len()
+        builder := builder.StringBuilder{}
+        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()
@@ -79,6 +107,10 @@ func (parser *paramParser)parseOne(v interface{}) {
     }
 }
 
+func ParseSliceParamString(src string) []string {
+    return strings.Split(src, slice_param_separator)
+}
+
 func structKey(oi *StructInfo, field string) string {
     return oi.Name + "." + field
 }

test/reflection_test.go

@@ -162,6 +162,20 @@ func TestReflectionParseComplex(t *testing.T) {
     }
 }
 
+func TestReflectionParseSlice(t *testing.T) {
+    ret := reflection.ParseParams([]int{1,2,3,4})
+    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)
+        }
+    }
+}
+
 func TestSimpleTypeTime(t *testing.T) {
     ret := reflection.IsSimpleObject(time.Time{})
     if !ret {

test/xmlparse_test.go

@@ -369,3 +369,25 @@ func TestXmlDynamicWhere(t *testing.T) {
         }
     })
 }
+
+func TestXmlDynamicForeach(t *testing.T) {
+    src := `SELECT * FROM PERSON WHERE IN
+        <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 := m.Replace(params)
+        t.Logf("arg first : %s\n", ret)
+
+    })
+}