增加直接执行sql以go template方式解析

Author: xfali

README.md

@@ -115,8 +115,10 @@ func Run() {
 }
 ```
 
-### 5、说明
+### 5、解析说明
+#### 5.1、内置动态解析
 
+内置动态解析是gobatis类Mybatis的解析方案（目前是xml mapper文件和直接执行sql的默认解析方式）：
 1. ${}表示直接替换，#{}防止sql注入
 2. 与Mybatis类似，语句中${0}、${1}、${2}...${n} 对应的是Param方法中对应的不定参数，最终替换和调用底层Driver
 3. Param方法接受简单类型的不定参数（string、int、time、float等）、struct、map，底层自动解析获得参数，用法为：
@@ -140,7 +142,33 @@ session.Select("select * from test_table where username = #{TestTable.username}"
 
   对应sql参数中的#{StructName.Field1}、#{StructName.Field2}...
 
+#### 5.2、go template解析
 
+使用go template解析，遵循template解析规则，是template mapper文件的解析方式。
+
+如要要修改直接执行sql的默认解析方式，可通过：
+```cassandraql
+    sessionManager.SetParserFactory(gobatis.TemplateParserFactory)
+```
+或者
+```cassandraql
+    session.SetParserFactory(gobatis.TemplateParserFactory)
+```
+调用后可使用template的方式直接解析执行sql：
+```cassandraql
+session.Select("SELECT * FROM test_table WHERE id = {{.}}").Param(2).Result(&ret)
+```
+gobatis内置where、set、arg自定义函数，用于智能生成动态sql
+
+arg用于将对象动态转换为占位符，并保存为sql参数，如:
+```cassandraql
+SELECT * FROM TABLE_NAME WHERE name = {{arg .Name}}
+```
+以mysql为例，将解析为：
+```cassandraql
+SELECT * FROM TABLE_NAME WHERE name = ? 
+```
+同时Name的值将自动保存为SQL参数，自动传入，起到类似内置动态解析中#{MODEL.Name}的效果。
 ### 6、事务
 
 使用
@@ -292,17 +320,6 @@ DELETE FROM test_table
 {{where .Id "AND" "id = " (arg .Id) "" | where .Username "AND" "username = " (arg .Username) | where .Password "AND" "password = " (arg .Password) | where .Createtime "AND" "createtime = " (arg .Createtime)}}
 {{end}}
 ```
-其中where、set、arg是gobatis的自定义函数，用于智能生成动态sql
-
-arg用于将对象动态转换为占位符，并保存为SQL参数，如:
-```cassandraql
-SELECT * FROM TABLE_NAME WHERE name = {{arg .Name}}
-```
-以mysql为例，将解析为：
-```cassandraql
-SELECT * FROM TABLE_NAME WHERE name = ? 
-```
-同时Name的值将自动保存为SQL参数，自动传入，起到类似xml中#{MODEL.Name}的效果。
 
 ### 9、gobatis-cmd生成文件使用示例
 

errors/errcode.go

@@ -32,7 +32,9 @@ var (
 	PARSE_SQL_VAR_ERROR              = New("12001", "SQL PARSE ERROR")
 	PARSE_SQL_PARAM_ERROR            = New("12002", "SQL PARSE parameter error")
 	PARSE_SQL_PARAM_VAR_NUMBER_ERROR = New("12003", "SQL PARSE parameter var number error")
+	PARSE_PARSER_NIL_ERROR           = New("12004", "Dynamic sql parser is nil error")
 	PARSE_DYNAMIC_SQL_ERROR          = New("12010", "Parse dynamic sql error")
+	PARSE_TEMPLATE_NIL_ERROR         = New("12101", "Parse template is nil")
 	EXECUTOR_COMMIT_ERROR            = New("21001", "executor was closed when transaction commit")
 	EXECUTOR_BEGIN_ERROR             = New("21002", "executor was closed when transaction begin")
 	EXECUTOR_QUERY_ERROR             = New("21003", "executor was closed when exec sql")

parsing/template/dynamic.go

@@ -17,6 +17,11 @@ const (
 	argPlaceHolder       = "_xfali_Arg_Holder"
 	argPlaceHolderLen    = 17
 	argPlaceHolderFormat = "%s%08d"
+
+	FuncNameSet   = "set"
+	FuncNameWhere = "where"
+	FuncNameArg   = "arg"
+	FuncNameAdd   = "add"
 )
 
 type Dynamic interface {
@@ -34,8 +39,9 @@ func dummyWhere(b interface{}, cond, column string, value interface{}, origin st
 	return origin
 }
 
+//return as fast as possible
 func dummyParam(p interface{}) string {
-	return fmt.Sprint(p)
+	return ""
 }
 
 func dummyNil(p interface{}) bool {
@@ -49,11 +55,11 @@ func commonAdd(a, b int) int {
 type DummyDynamic struct{}
 
 var dummyFuncMap = template.FuncMap{
-	"set":   dummyUpdateSet,
-	"where": dummyWhere,
-	"arg":   dummyParam,
+	FuncNameSet:   dummyUpdateSet,
+	FuncNameWhere: dummyWhere,
+	FuncNameArg:   dummyParam,
 
-	"add": commonAdd,
+	FuncNameAdd: commonAdd,
 }
 
 var gDummyDynamic = &DummyDynamic{}
@@ -79,11 +85,11 @@ type CommonDynamic struct {
 
 func (d *CommonDynamic) getFuncMap() template.FuncMap {
 	return template.FuncMap{
-		"set":   d.UpdateSet,
-		"where": d.Where,
-		"arg":   d.Param,
+		FuncNameSet:   d.UpdateSet,
+		FuncNameWhere: d.Where,
+		FuncNameArg:   d.Param,
 
-		"add": commonAdd,
+		FuncNameAdd: commonAdd,
 	}
 }
 

parsing/template/parse.go

@@ -6,6 +6,7 @@
 package template
 
 import (
+	"github.com/xfali/gobatis/errors"
 	"github.com/xfali/gobatis/logging"
 	"github.com/xfali/gobatis/parsing/sqlparser"
 	"io/ioutil"
@@ -18,8 +19,21 @@ type Parser struct {
 	tpl *template.Template
 }
 
+func CreateParser(data []byte) (*Parser, error) {
+	tpl := template.New("")
+	tpl = tpl.Funcs(dummyFuncMap)
+	tpl, err := tpl.Parse(string(data))
+	if err != nil {
+		return nil, err
+	}
+	return &Parser{tpl: tpl}, nil
+}
+
 //only use first param
 func (p *Parser) ParseMetadata(driverName string, params ...interface{}) (*sqlparser.Metadata, error) {
+	if p.tpl == nil {
+		return nil, errors.PARSE_TEMPLATE_NIL_ERROR
+	}
 	b := strings.Builder{}
 	var param interface{} = nil
 	if len(params) > 0 {

sqlmanager.go

@@ -57,15 +57,12 @@ func FindTemplateSqlParser(sqlId string) (sqlparser.SqlParser, bool) {
 	return g_sql_mgr.templateSqlMgr.FindSqlParser(sqlId)
 }
 
-func FindSqlParser(sqlId string) sqlparser.SqlParser {
-	ret, ok := FindDynamicSqlParser(sqlId)
-	if !ok {
-		ret, ok = FindTemplateSqlParser(sqlId)
-	}
-	//FIXME: 当没有查找到sqlId对应的sql语句，则尝试使用sqlId直接操作数据库
-	//该设计可能需要设计一个更合理的方式
-	if !ok {
-		return &parsing.DynamicData{OriginData: sqlId}
-	}
-	return ret
+type ParserFactory func(sql string) (sqlparser.SqlParser, error)
+
+func DynamicParserFactory(sql string) (sqlparser.SqlParser, error) {
+	return &parsing.DynamicData{OriginData: sql}, nil
 }
+
+func TemplateParserFactory(sql string) (sqlparser.SqlParser, error) {
+	return template.CreateParser([]byte(sql))
+}

sqlrunner.go

@@ -19,11 +19,15 @@ import (
 )
 
 type SessionManager struct {
-	factory factory.Factory
+	factory       factory.Factory
+	ParserFactory ParserFactory
 }
 
 func NewSessionManager(factory factory.Factory) *SessionManager {
-	return &SessionManager{factory: factory}
+	return &SessionManager{
+		factory:       factory,
+		ParserFactory: DynamicParserFactory,
+	}
 }
 
 type Runner interface {
@@ -41,10 +45,11 @@ type Runner interface {
 }
 
 type Session struct {
-	ctx     context.Context
-	log     logging.LogFunc
-	session session.SqlSession
-	driver  string
+	ctx           context.Context
+	log           logging.LogFunc
+	session       session.SqlSession
+	driver        string
+	ParserFactory ParserFactory
 }
 
 type BaseRunner struct {
@@ -79,13 +84,19 @@ type DeleteRunner struct {
 //使用一个session操作数据库
 func (this *SessionManager) NewSession() *Session {
 	return &Session{
-		ctx:     context.Background(),
-		log:     this.factory.LogFunc(),
-		session: this.factory.CreateSession(),
-		driver:  this.factory.GetDataSource().DriverName(),
+		ctx:           context.Background(),
+		log:           this.factory.LogFunc(),
+		session:       this.factory.CreateSession(),
+		driver:        this.factory.GetDataSource().DriverName(),
+		ParserFactory: this.ParserFactory,
 	}
 }
 
+//修改sql解析器创建者
+func (this *SessionManager) SetParserFactory(fac ParserFactory) {
+	this.ParserFactory = fac
+}
+
 func (this *Session) SetContext(ctx context.Context) *Session {
 	this.ctx = ctx
 	return this
@@ -95,6 +106,11 @@ func (this *Session) GetContext() context.Context {
 	return this.ctx
 }
 
+//修改sql解析器创建者
+func (this *Session) SetParserFactory(fac ParserFactory) {
+	this.ParserFactory = fac
+}
+
 //开启事务执行语句
 //返回nil则提交，返回error回滚
 //抛出异常错误触发回滚
@@ -115,19 +131,19 @@ func (this *Session) Tx(txFunc func(session *Session) error) {
 }
 
 func (this *Session) Select(sql string) Runner {
-	return this.createSelect(FindSqlParser(sql))
+	return this.createSelect(this.findSqlParser(sql))
 }
 
 func (this *Session) Update(sql string) Runner {
-	return this.createUpdate(FindSqlParser(sql))
+	return this.createUpdate(this.findSqlParser(sql))
 }
 
 func (this *Session) Delete(sql string) Runner {
-	return this.createDelete(FindSqlParser(sql))
+	return this.createDelete(this.findSqlParser(sql))
 }
 
 func (this *Session) Insert(sql string) Runner {
-	return this.createInsert(FindSqlParser(sql))
+	return this.createInsert(this.findSqlParser(sql))
 }
 
 func (this *BaseRunner) Param(params ...interface{}) Runner {
@@ -143,6 +159,11 @@ func (this *BaseRunner) Param(params ...interface{}) Runner {
 	//    }
 	//}
 
+	if this.sqlParser == nil {
+		this.log(logging.WARN, errors.PARSE_PARSER_NIL_ERROR.Error())
+		return this
+	}
+
 	md, err := this.sqlParser.ParseMetadata(this.driver, params...)
 
 	if err == nil {
@@ -152,7 +173,7 @@ func (this *BaseRunner) Param(params ...interface{}) Runner {
 			this.log(logging.WARN, "sql action not match expect %s get %s", this.action, md.Action)
 		}
 	} else {
-		this.log(logging.WARN, "%s", err.Error())
+		this.log(logging.WARN, err.Error())
 	}
 	return this.this
 }
@@ -232,7 +253,7 @@ func (this *BaseRunner) LastInsertId() int64 {
 	return -1
 }
 
-func (this *Session)createSelect(parser sqlparser.SqlParser) Runner {
+func (this *Session) createSelect(parser sqlparser.SqlParser) Runner {
 	ret := &SelectRunner{}
 	ret.action = sqlparser.SELECT
 	ret.log = this.log
@@ -244,7 +265,7 @@ func (this *Session)createSelect(parser sqlparser.SqlParser) Runner {
 	return ret
 }
 
-func (this *Session)createUpdate(parser sqlparser.SqlParser) Runner {
+func (this *Session) createUpdate(parser sqlparser.SqlParser) Runner {
 	ret := &UpdateRunner{}
 	ret.action = sqlparser.UPDATE
 	ret.log = this.log
@@ -256,7 +277,7 @@ func (this *Session)createUpdate(parser sqlparser.SqlParser) Runner {
 	return ret
 }
 
-func (this *Session)createDelete(parser sqlparser.SqlParser) Runner {
+func (this *Session) createDelete(parser sqlparser.SqlParser) Runner {
 	ret := &DeleteRunner{}
 	ret.action = sqlparser.DELETE
 	ret.log = this.log
@@ -268,7 +289,7 @@ func (this *Session)createDelete(parser sqlparser.SqlParser) Runner {
 	return ret
 }
 
-func (this *Session)createInsert(parser sqlparser.SqlParser) Runner {
+func (this *Session) createInsert(parser sqlparser.SqlParser) Runner {
 	ret := &InsertRunner{}
 	ret.action = sqlparser.INSERT
 	ret.log = this.log
@@ -279,3 +300,21 @@ func (this *Session)createInsert(parser sqlparser.SqlParser) Runner {
 	ret.this = ret
 	return ret
 }
+
+func (this *Session) findSqlParser(sqlId string) sqlparser.SqlParser {
+	ret, ok := FindDynamicSqlParser(sqlId)
+	if !ok {
+		ret, ok = FindTemplateSqlParser(sqlId)
+	}
+	//FIXME: 当没有查找到sqlId对应的sql语句，则尝试使用sqlId直接操作数据库
+	//该设计可能需要设计一个更合理的方式
+	if !ok {
+		d, err := this.ParserFactory(sqlId)
+		if err != nil {
+			this.log(logging.WARN, err.Error())
+			return nil
+		}
+		return d
+	}
+	return ret
+}

test/postgresql/runner_test.go

@@ -250,3 +250,24 @@ func TestTx3(t *testing.T) {
 		return nil
 	})
 }
+
+func TestSession(t *testing.T) {
+	t.Run("default", func(t *testing.T) {
+		mgr := gobatis.NewSessionManager(connect())
+		var ret []TestTable
+		mgr.NewSession().Select("SELECT * FROM test_table WHERE id = #{0}").Param(2).Result(&ret)
+		t.Log(ret)
+	})
+
+	t.Run("default", func(t *testing.T) {
+		mgr := gobatis.NewSessionManager(connect())
+		mgr.SetParserFactory(gobatis.TemplateParserFactory)
+		var ret1 []TestTable
+		mgr.NewSession().Select("SELECT * FROM test_table WHERE id = {{arg .}}").Param(2).Result(&ret1)
+		t.Log(ret1)
+
+		var ret2 []TestTable
+		mgr.NewSession().Select("SELECT * FROM test_table WHERE id = {{.}}").Param(2).Result(&ret2)
+		t.Log(ret2)
+	})
+}