add template support, and postgresql test

Author: xfali

datasource/postgre_datasource.go

@@ -24,5 +24,8 @@ func (ds *PostgreDataSource) DriverName() string {
 }
 
 func (ds *PostgreDataSource) DriverInfo() string {
+	if ds.SslMode == "" {
+		ds.SslMode = "disable"
+	}
 	return fmt.Sprintf("host=%s port=%d user=%s password=%s dbname=%s sslmode=%s", ds.Host, ds.Port, ds.Username, ds.Password, ds.DBName, ds.SslMode)
 }

go.mod

@@ -4,5 +4,6 @@ go 1.11
 
 require (
 	github.com/go-sql-driver/mysql v1.4.1 // indirect
+	github.com/lib/pq v1.3.0 // indirect
 	github.com/mattn/go-sqlite3 v1.10.0 // indirect
 )

go.sum

@@ -1,4 +1,6 @@
 github.com/go-sql-driver/mysql v1.4.1 h1:g24URVg0OFbNUTx9qqY1IRZ9D9z3iPyi5zKhQZpNwpA=
 github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
+github.com/lib/pq v1.3.0 h1:/qkRGz8zljWiDcFvgpwUpwIAPu3r07TDvs3Rws+o/pU=
+github.com/lib/pq v1.3.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
 github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o=
 github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc=

parsing/dynamics.go

@@ -10,6 +10,7 @@ package parsing
 
 import (
 	"github.com/xfali/gobatis/logging"
+	"github.com/xfali/gobatis/parsing/sqlparser"
 	"github.com/xfali/gobatis/reflection"
 	"reflect"
 	"strings"
@@ -67,3 +68,9 @@ func (m *DynamicData) ReplaceWithMap(objParams map[string]interface{}) string {
 	}
 	return ret
 }
+
+func (m *DynamicData) ParseMetadata(driverName string, params ...interface{})(*sqlparser.Metadata, error) {
+	paramMap := reflection.ParseParams(params...)
+	sqlStr := m.ReplaceWithMap(paramMap)
+	return sqlparser.ParseWithParamMap(driverName, sqlStr, paramMap)
+}

parsing/sqlparser/parse.go

@@ -30,6 +30,10 @@ type Metadata struct {
 	Params     []interface{}
 }
 
+type SqlParser interface {
+	ParseMetadata(driverName string, params ...interface{}) (*Metadata, error)
+}
+
 func SimpleParse(sql string) (*Metadata, error) {
 	ret := Metadata{}
 	sql = strings.Trim(sql, " ")
@@ -122,7 +126,7 @@ func ParseWithParams(sql string, params ...interface{}) (*Metadata, error) {
 	return &ret, nil
 }
 
-func ParseWithParamMap(sql string, params map[string]interface{}) (*Metadata, error) {
+func ParseWithParamMap(driverName, sql string, params map[string]interface{}) (*Metadata, error) {
 	ret := Metadata{}
 	sql = strings.Trim(sql, " ")
 	action := sql[:6]
@@ -133,6 +137,9 @@ func ParseWithParamMap(sql string, params map[string]interface{}) (*Metadata, er
 	subStr := sql
 	firstIndex, lastIndex := -1, -1
 	var c string
+	var index int = 0
+	holder := selectHolder(driverName)
+
 	for {
 		firstIndex = strings.Index(subStr, "{")
 		if firstIndex == -1 || firstIndex == 0 {
@@ -156,7 +163,9 @@ func ParseWithParamMap(sql string, params map[string]interface{}) (*Metadata, er
 							subStr = strings.Replace(subStr, oldStr, newStr, -1)
 						} else if c == "#" {
 							oldStr := "#{" + varName + "}"
-							ret.PrepareSql = strings.Replace(ret.PrepareSql, oldStr, "?", -1)
+							index++
+							h := holder(index)
+							ret.PrepareSql = strings.Replace(ret.PrepareSql, oldStr, h, -1)
 							ret.Params = append(ret.Params, value)
 						}
 					} else {
@@ -171,6 +180,28 @@ func ParseWithParamMap(sql string, params map[string]interface{}) (*Metadata, er
 	return &ret, nil
 }
 
+type holder func(int) string
+
+var gHolderMap = map[string]holder{
+	"mysql":    mysqlHolder,
+	"postgres": postgresHolder,
+}
+
+func selectHolder(driverName string) holder {
+	if v, ok := gHolderMap[driverName]; ok {
+		return v
+	}
+	return mysqlHolder
+}
+
+func mysqlHolder(int) string {
+	return "?"
+}
+
+func postgresHolder(i int) string {
+	return "$" + strconv.Itoa(i)
+}
+
 func interface2String(i interface{}) string {
 	return fmt.Sprintf("%v", i)
 }

parsing/template/parse.go

@@ -0,0 +1,127 @@
+// Copyright (C) 2019-2020, Xiongfa Li.
+// @author xiongfa.li
+// @version V1.0
+// Description: 
+
+package template
+
+import (
+	"github.com/xfali/gobatis/logging"
+	"github.com/xfali/gobatis/parsing/sqlparser"
+	"html/template"
+	"io/ioutil"
+	"strings"
+	"sync"
+)
+
+type Parser struct {
+	tpl *template.Template
+}
+
+//only use first param
+func (p *Parser) ParseMetadata(driverName string, params ...interface{}) (*sqlparser.Metadata, error) {
+	b := strings.Builder{}
+	var param interface{} = nil
+	if len(params) > 0 {
+		param = params[0]
+	}
+
+	err := p.tpl.Execute(&b, param)
+	if err != nil {
+		return nil, err
+	}
+
+	ret := &sqlparser.Metadata{}
+	sql := strings.TrimSpace(b.String())
+	action := sql[:6]
+	action = strings.ToLower(action)
+	ret.Action = action
+	ret.PrepareSql = sql
+	ret.Params = nil
+
+	return ret, nil
+}
+
+func updateSet(sets ... string) string {
+	b := strings.Builder{}
+	for _, v := range sets {
+		if len(v) > 0 {
+			b.WriteString(strings.TrimSpace(v))
+			b.WriteString(",")
+		}
+	}
+	setStr := b.String()
+	if len(setStr) == 0 {
+		return ""
+	} else {
+		return " SET " + setStr[:len(setStr)-1]
+	}
+}
+
+type Manager struct {
+	sqlMap map[string]*Parser
+	lock   sync.Mutex
+}
+
+func NewManager() *Manager {
+	return &Manager{
+		sqlMap: map[string]*Parser{},
+	}
+}
+
+func (m *Manager) RegisterData(data []byte) error {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	tpl := template.New("")
+	tpl = tpl.Funcs(template.FuncMap{
+		"updateSet": updateSet,
+	})
+	tpl, err := tpl.Parse(string(data))
+	if err != nil {
+		logging.Warn("register template data failed: %s err: %v\n", string(data), err)
+		return err
+	}
+
+	tpls := tpl.Templates()
+	for _, v := range tpls {
+		m.sqlMap[v.Name()] = &Parser{v}
+	}
+
+	return nil
+}
+
+func (m *Manager) RegisterFile(file string) error {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	tpl := template.New("")
+	tpl = tpl.Funcs(template.FuncMap{
+		"updateSet": updateSet,
+	})
+	data, err := ioutil.ReadFile(file)
+	if err != nil {
+		logging.Warn("register template file failed: %s err: %v\n", file, err)
+		return err
+	}
+	tpl, err = tpl.Parse(string(data))
+	if err != nil {
+		logging.Warn("register template file failed: %s err: %v\n", file, err)
+		return err
+	}
+
+	tpls := tpl.Templates()
+	for _, v := range tpls {
+		m.sqlMap[v.Name()] = &Parser{v}
+	}
+
+	return nil
+}
+
+func (m *Manager) FindSql(sqlId string) (*Parser, bool) {
+	m.lock.Lock()
+	defer m.lock.Unlock()
+
+	v, ok := m.sqlMap[sqlId]
+	return v, ok
+}

sqlmanager.go

@@ -12,40 +12,50 @@ import (
 	"github.com/xfali/gobatis/errors"
 	"github.com/xfali/gobatis/logging"
 	"github.com/xfali/gobatis/parsing"
+	"github.com/xfali/gobatis/parsing/sqlparser"
+	"github.com/xfali/gobatis/parsing/template"
 	"github.com/xfali/gobatis/parsing/xml"
 	"sync"
 )
 
-type SqlManager struct {
+type dynamicSqlManager struct {
 	sqlMap map[string]*parsing.DynamicData
 	lock   sync.Mutex
 }
 
-var g_sql_mgr = SqlManager{sqlMap: map[string]*parsing.DynamicData{}}
+type sqlManager struct {
+	dynamicSqlMgr  *dynamicSqlManager
+	templateSqlMgr *template.Manager
+}
+
+var g_sql_mgr = sqlManager{
+	dynamicSqlMgr:  &dynamicSqlManager{sqlMap: map[string]*parsing.DynamicData{}},
+	templateSqlMgr: template.NewManager(),
+}
 
 func RegisterSql(sqlId string, sql string) error {
-	g_sql_mgr.lock.Lock()
-	defer g_sql_mgr.lock.Unlock()
+	g_sql_mgr.dynamicSqlMgr.lock.Lock()
+	defer g_sql_mgr.dynamicSqlMgr.lock.Unlock()
 
-	if _, ok := g_sql_mgr.sqlMap[sqlId]; ok {
+	if _, ok := g_sql_mgr.dynamicSqlMgr.sqlMap[sqlId]; ok {
 		return errors.SQL_ID_DUPLICATES
 	} else {
 		dd := &parsing.DynamicData{OriginData: sql}
-		g_sql_mgr.sqlMap[sqlId] = dd
+		g_sql_mgr.dynamicSqlMgr.sqlMap[sqlId] = dd
 	}
 	return nil
 }
 
 func UnregisterSql(sqlId string) {
-	g_sql_mgr.lock.Lock()
-	defer g_sql_mgr.lock.Unlock()
+	g_sql_mgr.dynamicSqlMgr.lock.Lock()
+	defer g_sql_mgr.dynamicSqlMgr.lock.Unlock()
 
-	delete(g_sql_mgr.sqlMap, sqlId)
+	delete(g_sql_mgr.dynamicSqlMgr.sqlMap, sqlId)
 }
 
 func RegisterMapperData(data []byte) error {
-	g_sql_mgr.lock.Lock()
-	defer g_sql_mgr.lock.Unlock()
+	g_sql_mgr.dynamicSqlMgr.lock.Lock()
+	defer g_sql_mgr.dynamicSqlMgr.lock.Unlock()
 
 	mapper, err := xml.Parse(data)
 	if err != nil {
@@ -57,8 +67,8 @@ func RegisterMapperData(data []byte) error {
 }
 
 func RegisterMapperFile(file string) error {
-	g_sql_mgr.lock.Lock()
-	defer g_sql_mgr.lock.Unlock()
+	g_sql_mgr.dynamicSqlMgr.lock.Lock()
+	defer g_sql_mgr.dynamicSqlMgr.lock.Unlock()
 
 	mapper, err := xml.ParseFile(file)
 	if err != nil {
@@ -72,18 +82,31 @@ func RegisterMapperFile(file string) error {
 func formatMapper(mapper *xml.Mapper) error {
 	ret := mapper.Format()
 	for k, v := range ret {
-		if _, ok := g_sql_mgr.sqlMap[k]; ok {
+		if _, ok := g_sql_mgr.dynamicSqlMgr.sqlMap[k]; ok {
 			return errors.SQL_ID_DUPLICATES
 		} else {
-			g_sql_mgr.sqlMap[k] = v
+			g_sql_mgr.dynamicSqlMgr.sqlMap[k] = v
 		}
 	}
 	return nil
 }
 
-func FindSql(sqlId string) *parsing.DynamicData {
-	g_sql_mgr.lock.Lock()
-	defer g_sql_mgr.lock.Unlock()
+func FindDynamicSql(sqlId string) (sqlparser.SqlParser, bool) {
+	g_sql_mgr.dynamicSqlMgr.lock.Lock()
+	defer g_sql_mgr.dynamicSqlMgr.lock.Unlock()
+
+	v, ok := g_sql_mgr.dynamicSqlMgr.sqlMap[sqlId]
+	return v, ok
+}
+
+func RegisterTemplateData(data []byte) error {
+	return g_sql_mgr.templateSqlMgr.RegisterData(data)
+}
+
+func RegisterTemplateFile(file string) error {
+	return g_sql_mgr.templateSqlMgr.RegisterFile(file)
+}
 
-	return g_sql_mgr.sqlMap[sqlId]
+func FindTemplateSql(sqlId string) (sqlparser.SqlParser, bool) {
+	return g_sql_mgr.templateSqlMgr.FindSql(sqlId)
 }